text.xml

<data><status>success</status><response><id>125690</id><event_id>10089</event_id><name>Agenda</name><type>agenda</type><icon_class>agenda</icon_class><color_class>red</color_class><page>home</page><partner_name>excel</partner_name><partner_token>a:0:{}</partner_token><self_edit_from></self_edit_from><self_edit_invite></self_edit_invite><self_edit_subject></self_edit_subject><status>1</status><position>0</position><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690</url><items><item><id>679912</id><topic>Registration &amp; Breakfast</topic><description>n/a</description><date>2015-11-07</date><start_time>08:30:00</start_time><end_time>09:30:00</end_time><location>Lobby</location><external_id>30</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 8:30am</display_start_time><display_end_time> 9:30am</display_end_time><date_t>1446872400</date_t><start_time_t>1446903000</start_time_t><end_time_t>1446906600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679912</url></item><item><id>679913</id><topic>Welcome &amp; Morning Keynote (Brett Cannon)</topic><description>n/a</description><date>2015-11-07</date><start_time>09:30:00</start_time><end_time>10:30:00</end_time><location>Lobby</location><external_id>31</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 9:30am</display_start_time><display_end_time>10:30am</display_end_time><date_t>1446872400</date_t><start_time_t>1446906600</start_time_t><end_time_t>1446910200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679913</url></item><item><id>679921</id><topic>ORM your ORM</topic><description>In this talk we'll present the inconveniences of working directly with objects returned by an ORM. We'll discuss:



- the issues of having database sessions attached to objects;

- the ability to maintain independence and flexibility around different storage solutions;

- and we will also talk about the general question of how to decide which object layer you should base your application logic on.



This talk is inspired by a real-world use case, and we'll present the before and after states of implementing our current (production) solution: a database-agnostic data service API that promotes immutable objects for any module to consume.</description><date>2015-11-07</date><start_time>10:40:00</start_time><end_time>11:10:00</end_time><location>Room 1160</location><external_id>40</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016570</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>10:40am</display_start_time><display_end_time>11:10am</display_end_time><date_t>1446872400</date_t><start_time_t>1446910800</start_time_t><end_time_t>1446912600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679921</url></item><item><id>679922</id><topic>Is your Python application secure?</topic><description>In today’s world, it's easier than ever to innovate and create great web applications. You release often, but let’s be honest, if you're like most developers out there, you don't spend your days worrying about security. You know it’s important, but you aren’t security savvy. So ask yourself, is your Python application secure? Come learn some of the different ways a hacker (cracker) can attack your code, and some of the best practices out there. In the end, your security is your users’ security.</description><date>2015-11-07</date><start_time>10:40:00</start_time><end_time>11:10:00</end_time><location>Room 1180</location><external_id>41</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016571</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>10:40am</display_start_time><display_end_time>11:10am</display_end_time><date_t>1446872400</date_t><start_time_t>1446910800</start_time_t><end_time_t>1446912600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679922</url></item><item><id>679924</id><topic>Hacking Structural Biology with Python and Pandas</topic><description>The dynamic motions of biomolecules like DNA, RNA, and proteins are integral to our understanding of drugs, disease, and human health. By performing large-scale supercomputer simulations, one can model the motion of proteins in ways impractical or impossible using traditional lab bench experiments. 



While data science approaches are ubiquitous in the field of genomics, commonly dealing with massive genetic sequence and expression datasets, the application of ""big data"" methodology is infrequently used in the field of structural biology due to the high computational expense of running simulations. However, advances in high-performance computing are resulting in increased dataset sizes and data analysis is emerging as the primary bottleneck to scientific discovery.



In this talk, I present the use of Python and Pandas to accelerate analysis of time series data extracted from molecular dynamics trajectories. The application of this approach is directed at the study of the voltage-gated sodium channel, a protein found in human neurons that is responsible for propagating nerve impulses. Using a Jupyter notebook, I perform exploratory analysis on a large dataset of trajectories and arrive at a mechanistic model for the function of this protein. This model may then be used to quantify how genetic diseases and drugs might alter the function of the protein in subsequent research."</description><date>2015-11-07</date><start_time>10:40:00</start_time><end_time>11:10:00</end_time><location>Room 1170</location><external_id>43</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016572</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>10:40am</display_start_time><display_end_time>11:10am</display_end_time><date_t>1446872400</date_t><start_time_t>1446910800</start_time_t><end_time_t>1446912600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679924</url></item><item><id>679962</id><topic>Building HATEOAS driven RESTful APIs with ripozo</topic><description>If you have spent any time building RESTful API's you are sure to come across someone claiming you are doing it incorrectly because it does not incorporate HATEOAS. Even Roy Fielding asserts that an application must be driven by hypermedia to be RESTful! Many will claim that the tooling simply "isn't there yet". In this talk we'll disprove this assumption and walk you through creating hypermedia driven APIs with ripozo. We'll show you why this makes developing truly RESTful applications painless and even expose you to clients that make the beauty of self discovering APIs evident.



[Register for this tutorial](https://github.com/pyconca/2015-wiki/wiki/tutorials)</description><date>2015-11-07</date><start_time>10:40:00</start_time><end_time>11:50:00</end_time><location>Tutorial Room 2195</location><external_id>83</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016616</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>10:40am</display_start_time><display_end_time>11:50am</display_end_time><date_t>1446872400</date_t><start_time_t>1446910800</start_time_t><end_time_t>1446915000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679962</url></item><item><id>679923</id><topic>How Python helped create the Visual Effects for an Emmy Nominated TV Show</topic><description>The extent to which programming is used in the production of Visual Effects can be somewhat of a mystery to an outsider of the field. Broadly speaking, it is used by 4 sets of people / categories with overlapping responsibilities.



Computer Graphics Engineers, Math, CS, Physics PhD’s and others in similar positions undertake the responsibility of very low level research and development such as creation of ‘shading’ and ‘rendering’ solutions, implementation of physics simulation algorithms, etc. Their development efforts help create the core toolset artists utilize when creating visuals. They either extend the possibilities that existing 3D software packages offer (like Maya, 3DS Max, Houdini and more) or create entirely new tools.



Pipeline TD’s and Engineers build and maintain the visual effects studio pipeline and help facilitate the production efficiently by managing the data-flow. This mainly involves building tools and plugins that interface with the 3D software packages that are in use or creating stand-alone desktop applications.



Technical Directors for each department address the particular needs of their departments by building scripts, tools, plugins — whatever the problem at hand requires. They usually interface with the tools that Engineers upstream build and with the 3D software packages that are already in use to achieve the solutions that they are after.



Eager Artists aka Budding Programmers are artists that are frustrated by the limitations of the toolset that they are given and devise automation solutions using the API of the software in use to build scripts and tools that helps with the redundant, repetitive, boilerplate tasks.



Almost all the software packages that are used in VFX nowadays have a Python API. Moreover programs are moving towards using PySide in implementing their visual interface, which further enables artists to utilize this toolkit to build their own GUI solutions — either integrated to the software or as a standalone desktop application. Wherever you look, Python dominates the VFX landscape — except for tasks that are performance critical. From the low level workings of the studio pipeline to the front-end of Visual Effects production where viewer facing visuals are created, Python facilitates delivery of cutting edge effects on time and on budget.



When a group of visual effects artists were asked to deliver an episode for an immensely popular TV Show involving one of the biggest CG battle scenes to be ever seen on the TV so far, it was obvious that Python was going to play a huge part in their workflow.



This talk focuses on the perspective of the artists and technical directors in this VFX landscape and various ways they utilize Python in production to come up with solutions for movies and shows that entertains millions of people around the globe.</description><date>2015-11-07</date><start_time>11:15:00</start_time><end_time>11:45:00</end_time><location>Room 1180</location><external_id>42</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016574</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>11:15am</display_start_time><display_end_time>11:45am</display_end_time><date_t>1446872400</date_t><start_time_t>1446912900</start_time_t><end_time_t>1446914700</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679923</url></item><item><id>679925</id><topic>Python's New Type Hints in Action... In JavaScript</topic><description>Depending on who you ask, PEP 484's Type Hints are either the next big thing in Python, or the harbinger of doom upon our entire community. Which is it?



Allowing optional static typing in Python will bring with it some benefits that other languages have had for years: IDEs will be able to do code completion better; a whole class of boring tests will fall out automatically; and some bugs will be easier to catch. 



But this is also undeniably a huge change of direction: will it mean you have to substantially change your code style? Will Python's simple expressiveness suddenly become unattainable thanks to clumsy Java-style type declarations?



To show how PEP 484's Gradual Typing system works, we're going to look at TypeScript, a minimal implementation of Gradual Typing over JavaScript. We'll see how the type system works, and how it fits into the already thriving JavaScript developer community, where most people aren't using type hints at all.



We'll draw some parallels with how Python's implementation will work, and see what Python can learn from a language that has successfully made the jump to a type-hinted world.</description><date>2015-11-07</date><start_time>11:15:00</start_time><end_time>11:45:00</end_time><location>Room 1160</location><external_id>44</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016573</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>11:15am</display_start_time><display_end_time>11:45am</display_end_time><date_t>1446872400</date_t><start_time_t>1446912900</start_time_t><end_time_t>1446914700</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679925</url></item><item><id>679926</id><topic>Matplotlib: Up and Running</topic><description>Matplotlib is the de facto standard for data visualization in Python, but getting started with it can be a little bit tough. Take a look at three different matplotlib tutorials, and chances are, you'll see at least two, if not three, different ways to interact with matplotlib! Understanding the correct way may not always be obvious. 



Now, fast forward past the basics. You've created a few visualizations with the aid of whatever tutorials you've found online, but you still don't feel like you have a good grip on how matplotlib works. You call the plot function several different ways and it seems to work just fine in the tutorials, but it doesn't seem to be doing what you want it to now. Oh, and not to mention, why do I need to call the show() function sometimes and not others? These are all the types of questions that I had when I was first learning matplotlib and it took a bit of work to find the answers to all of them. 



 In this talk I cover everything that I wish I knew when I was first learning matplotlib. I'll cover the three main interfaces to the library: pylab, pyplot, and the OO API, and you'll learn when and how to use each one. Then we'll go into a bit more detail on the architecture of matplotlib, and deep dive into the plot function to understand just how versatile it is and where its limits arise. Finally, we'll look at several new libraries built atop the venerable visualization library that have come about in the past few years to take matplotlib to the next level. During the course of the talk, you'll also see several tips and tricks to make matplotlib a little friendlier.



 It's been my observation that getting started with matplotlib is easy due to the wealth of tutorials online. A problem does tend to arise, however, when a tutorial can't be found for the current task at hand. Many times I've seen individuals, who have used matplotlib in the past, at a loss when they need to do something they've never done before. The goal of this talk is to give the attendees the understanding they need to reason properly about the library and to make it possible for them to move away from copy-n-paste coding to actually writing up their own visualization scripts.</description><date>2015-11-07</date><start_time>11:15:00</start_time><end_time>11:45:00</end_time><location>Room 1170</location><external_id>45</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016575</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>11:15am</display_start_time><display_end_time>11:45am</display_end_time><date_t>1446872400</date_t><start_time_t>1446912900</start_time_t><end_time_t>1446914700</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679926</url></item><item><id>679927</id><topic>Exploring our Python Interpreter</topic><description>During my last CPython sprint, I started to contribute to the CPython code, and I wanted to understand the beast.



In this case, there is only one solution, trace the code from the beginning. From the command line to the interpreter, we will take part to an adventure.



* Overview of the structure of the Project and the directories.

* From the Py_Main function, to the interpreter

* the used technics for the Lexer, Parser and the generation of the AST and of course of the Byte Code.

* we will see some byte codes with the dis module

* How does VM works, it’s a stack machine.

* the Interpreter and its main loop of the Virtual Machine.



The idea behind is just to show how CPython works for a new contributor to CPython</description><date>2015-11-07</date><start_time>11:50:00</start_time><end_time>12:20:00</end_time><location>Room 1180</location><external_id>46</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016577</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>11:50am</display_start_time><display_end_time>12:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446915000</start_time_t><end_time_t>1446916800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679927</url></item><item><id>679928</id><topic>Deconstructing Django with Flask</topic><description>Motivation: With the rise of micro services, API first sites and mobile the draw of a lightweight framework is stronger than ever.  Django and its proscriptive batteries included approach can feel too heavy.



- Django is awesome, but maybe I'm missing something with Flask thing. OMG, where do I start, there my so many choices

  - Major components of Django: ORM, routing, templating, views, forms, migrations, configuration, ReST, models, tasks, tests, static assets, authentication, sessions etc

  - templating, forms, static assets aren’t really needed for api/mobile use cases

  - for each remaining component offer the “best” flask library

  - build out a small API only app together using the ""best"" flask library</description><date>2015-11-07</date><start_time>11:50:00</start_time><end_time>12:20:00</end_time><location>Room 1170</location><external_id>47</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016578</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>11:50am</display_start_time><display_end_time>12:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446915000</start_time_t><end_time_t>1446916800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679928</url></item><item><id>679929</id><topic>Using Python and Docker to create a novel and scalable development environment solution.</topic><description>Local development environments are essential tools which help us run code on our own machines. Good development environments help us efficiently manage our workflow as we make code changes, and they can be adapted to fit a changing stack and team. In this talk, we’ll look at shortcomings of different development environment solutions, and how we’ve attempted to solve them with Python and Docker.



The simplest solution is to just run your app on the command line - for example with python my_app.py. This is easy and works well if your setup is simple.  But as you scale your stack, adding apps and developers, this approach becomes problematic.  When you have more than one app to run, you can run into dependency conflicts between apps.  When you add more developers, it becomes a challenge to reproduce your system configuration so that each app runs smoothly on each developer’s machine. Virtualenvs help these issues by providing a measure of isolation and reproducibility.  However they only partly solve the problem; environment variables, system libraries, and other system configuration all hamper reproducibility and isolation.



A common approach to these problems is to run code in a virtual machine.  This does increase the portability of an environment, but still comes with some issues.  Changing dependencies and configuration over time can prompt changes in the VM system state, which can create the same reproducibility issues as before.  Configuration management software can help, but comes with its own set of issues.  Additionally, virtual machines come with performance penalties; shared folders have poor performance, and the VM will consume tons of memory if you have a large stack.  Finally, apps running on the same VM can still suffer from lack of isolation. Conflicting system dependencies, apps that want to listen on the same port, and other issues will require workarounds.



Docker containers provide an opportunity to improve on these shortcomings.  Containers are by nature isolated and portable, and they come without the performance overhead that’s associated with virtual machines. However there are still problems to solve before containers can be managed easily in a development environment workflow. How are the containers launched in a reproducible way?  How are containers connected so that they can communicate as needed?  What happens when we need to make changes to the stack being run? We’ve built a Python app which manages docker containers and abstracts these processes.  Dusty (dusty.gc.com) knows how to run an arbitrarily complex stack based on a set of defined specs, and provides other workflow management features. We think that this approach is more portable, more scalable, and easier to use than other development environment solutions capable of running complex stacks.</description><date>2015-11-07</date><start_time>11:50:00</start_time><end_time>12:20:00</end_time><location>Room 1160</location><external_id>48</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016576</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>11:50am</display_start_time><display_end_time>12:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446915000</start_time_t><end_time_t>1446916800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679929</url></item><item><id>679914</id><topic>Lunch</topic><description>n/a</description><date>2015-11-07</date><start_time>12:20:00</start_time><end_time>13:40:00</end_time><location>Atrium</location><external_id>32</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time>12:20pm</display_start_time><display_end_time> 1:40pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446916800</start_time_t><end_time_t>1446921600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679914</url></item><item><id>679969</id><topic>Geolocation Apps with Django</topic><description>Latitude, longitude, altitude, and even iBeacons can be leveraged to enable geo-targeted experiences. But how do we build and optimize the server-side components to handle these requirements? Using a combination of libraries and techniques, we will illustrate these concepts. In this discussion everything from map clustering and caching, to distance calculations and polygonal layering will be demonstrated using Django, GeoDjango, Redis, and PostGIS as our tool belt.</description><date>2015-11-07</date><start_time>13:40:00</start_time><end_time>14:10:00</end_time><location>Room 1160</location><external_id>90</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016619</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 1:40pm</display_start_time><display_end_time> 2:10pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446921600</start_time_t><end_time_t>1446923400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679969</url></item><item><id>679930</id><topic>REBOUND, a high-performance Python/C package for simulating planetary and satellite orbits</topic><description>I will present REBOUND, an open-source package that can be used to simulate the motion of bodies in the Solar System, extra-solar planetary systems and Saturn’s rings. REBOUND has been developed by a group of astrophysicists at the University of Toronto. My talk will focus on several design challenges that we faced during the development, finding a balance between efficiency and usability that might be of wide interest to people working on high performance python code.



We opted for a design where all time-consuming algorithms are implemented in C. However, to easily setup and manipulate simulations, we developed a Python module to interface with REBOUND. This makes REBOUND very easy to use and allows us to leverage the power of Python and its supporting libraries to analyze and visualize simulation results.  



I will do a live demo and show how one can use REBOUND to simulate the Solar System with initial positions of planets, moons and spacecraft from a NASA database in just a few minutes.</description><date>2015-11-07</date><start_time>13:40:00</start_time><end_time>14:10:00</end_time><location>Room 1180</location><external_id>50</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016580</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 1:40pm</display_start_time><display_end_time> 2:10pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446921600</start_time_t><end_time_t>1446923400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679930</url></item><item><id>679931</id><topic>What you can do with Python, a relational database, SVN, and a little scripting in a data center</topic><description>The ability to rapidly deploy is a key element of any devops strategy, and the ability to stage and redeploy hardware is no different, especially in a large institution hosting 230+ networks.



Faced with an Institutional requirement to replace ALL of the 230+ border (demark) switches connecting academic and administrative departments to the University backbone in a cost-effective and timely manner, and the complication of dealing with a seriously high-latency practice to prepare networking hardware for first use, we were able to leverage elements of Python, Subversion, and PostgreSQL to massively scale up and speed up our capacity to stage and field new equipment, improving service levels and by extension providing a key element of internal DR/BC practice.



Although the project was left fallow after the initial replacement was completed, the lessons learned from this project have been very valuable when future projects were planned. This talk will focus generally on the problems at hand, focus on the solution architected and implemented, and end with specific points to remember during similar efforts in the future.</description><date>2015-11-07</date><start_time>13:40:00</start_time><end_time>14:10:00</end_time><location>Room 1170</location><external_id>51</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016581</speaker_id><speaker_id>3016604</speaker_id><speaker_id>3016614</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 1:40pm</display_start_time><display_end_time> 2:10pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446921600</start_time_t><end_time_t>1446923400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679931</url></item><item><id>679963</id><topic>Interactive Media Development with Python &amp; TouchDesigner</topic><description>In a world of smartphones, gestural sensors, and virtual reality, there is more than just a want for interactive and immersive media, there is an expectation for it. The reality is that as the world gravitates towards interactive and immersive media, Python is being chosen less and less by developers as their go-to tool because it lacks the facilities to quickly prototype and create architectures to support such process-intensive works. Compare Python with other languages and their respective creative coding frameworks and you'll begin to notice the startling gap in our toolset. With a wide gamut of choices ranging from C++ and openFrameworks or Cinder, Java environments like Processing, and even web technologies like Javascript, Flash and HTML, it's a shame that a comparable solution doesn't exist for Python. Regardless of the reason, there exists an alternative solution that has proven very successful: Derivative's TouchDesigner. 

[Register for this tutorial](https://github.com/pyconca/2015-wiki/wiki/tutorials)



Derivative's TouchDesigner has been a cornerstone in the immersive design and interactive technology industry for many years now, powering many of the leading live performances, events, and artistic installations around the world. With the release of TouchDesigner version 088, Python 3 has been deeply integrated into its architecture. This allows Python developers an easy way to create works beyond what's capable in Flash, Javascript, or Processing, such as driving multi-screen media walls, creating generative content with arrays of Microsoft Kinects and Leap Motions, interfacing with industry-standard audio and video equipment, processing of multi-layered 4k content for Oculus Rifts, projection mapping buildings and abstract surfaces, driving LED walls, lighting fixtures, and pyro for live concert tours, and more. This can all be developed inside of TouchDesigner's high-performance &amp; real-time media framework using Python. For more examples of types of works covered in this tutorial visit http://nvoid.com. 



The sections of this tutorial are as follows:



Part 1: Introductions, Definitions, Concepts, and Examples - General Introductions - Introduction to tools - Introduction to concepts of interactive media - Examples of interactive media installations - Breakdown of Python used in interactive media installations



Part 2: Why Python and TouchDesigner? - Advantages of Python vs C++ - Advantages of Python in the real world - Features and capabilities of TouchDesigner



Part 3: Demonstration and Live Coding - Prototyping, Analyzing, and Visualizing Sensor Data with Python - Get and Visualize Twitter data in real-time using Requests - Iterate and Render 3D geometry in real-time using Python</description><date>2015-11-07</date><start_time>13:40:00</start_time><end_time>15:10:00</end_time><location>Tutorial Room 2195</location><external_id>84</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016615</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 1:40pm</display_start_time><display_end_time> 3:10pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446921600</start_time_t><end_time_t>1446927000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679963</url></item><item><id>679932</id><topic>TBD</topic><description>TBD</description><date>2015-11-07</date><start_time>14:15:00</start_time><end_time>14:45:00</end_time><location>Room 1160</location><external_id>53</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016618</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 2:15pm</display_start_time><display_end_time> 2:45pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446923700</start_time_t><end_time_t>1446925500</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679932</url></item><item><id>679933</id><topic>Building Highly Decoupled Systems in Python</topic><description>With various architecture decisions like Microservices, Restful APIs, MVC, and many more being widely discussed, it's often difficult to determine what you need to build your application. However, these patterns and many other well designed architectures follow common best practices including low coupling, high cohesion, and strong interfaces. Understanding these underlying principals is key to making the best decisions for your use case.



In this discussion we will explore how highly decoupled systems with strong interface boundaries aid in the maintainability and velocity of a project, and how to build such a system using python.</description><date>2015-11-07</date><start_time>14:15:00</start_time><end_time>14:45:00</end_time><location>Room 1180</location><external_id>54</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016582</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 2:15pm</display_start_time><display_end_time> 2:45pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446923700</start_time_t><end_time_t>1446925500</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679933</url></item><item><id>679934</id><topic>Epic NHL goal celebration hack with a hue light show and real time machine learning</topic><description>This talk shows how Python was used to trigger an epic sound and light show whenever the Montreal Canadiens hockey team scored a goal in last season's playoffs.



The author trained a machine learning model to detect in real-time that a goal was just scored by the Habs based on the live audio feed of a game and to trigger a light show using Philips hues in his living room. The system was built using various Python modules, more specifically scikit-learn, pyaudio, librosa, phue and bottle.



The talk will cover every step of the hack from the creation of the dataset, the feature generation and the machine learning model training, the real-time audio feed processing to do real-time scoring and the programming of the light show.</description><date>2015-11-07</date><start_time>14:15:00</start_time><end_time>14:45:00</end_time><location>Room 1170</location><external_id>55</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016583</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 2:15pm</display_start_time><display_end_time> 2:45pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446923700</start_time_t><end_time_t>1446925500</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679934</url></item><item><id>679935</id><topic>Using Python to characterize the structure of wood.</topic><description>The energy-intensive nature of the mechanical pulping production process (disassembling wood chips into their constituent fibres to make pulp) has resulted in a great deal of work in the area of energy reduction strategies for the process. Prior-to-pulping wood chip compression processes fit this bill exactly and have been shown to reduce the energy consumed by the process as a whole by up to 15%, but are less than fully understood in their mechanism of action. This talk will cover the development of the computational and experimental tools that have been developed to characterize wood chips, and, ultimately, better understand the mechanics of the chip-compression process as a whole. Specifically: the development of an image analysis (via OpenCV)/model fitting (via scikit-learn) data analysis pipeline has allowed for a quantitative assessment of the micro-structure of wood.</description><date>2015-11-07</date><start_time>14:50:00</start_time><end_time>15:00:00</end_time><location>Room 1160</location><external_id>56</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016584</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 2:50pm</display_start_time><display_end_time> 3:00pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446925800</start_time_t><end_time_t>1446926400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679935</url></item><item><id>679936</id><topic>Earthquakes and the Moon</topic><description>Timekeeping is no easy business. This talk tells the story of how earthquakes and even the Moon force the concept of the "leap second", and the debacle in 2012 that took down most of the Internet. It also goes into some detail at how Python is handling this scenario.</description><date>2015-11-07</date><start_time>14:50:00</start_time><end_time>15:20:00</end_time><location>Room 1180</location><external_id>57</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016587</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 2:50pm</display_start_time><display_end_time> 3:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446925800</start_time_t><end_time_t>1446927600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679936</url></item><item><id>679937</id><topic>Scaling Python</topic><description>You might have heard from smart people that dynamic languages are not suitable for large projects. We're going to look at what it takes to manage one of the largest Python projects powering public clouds at Dreamhost and Rackspace as well as private ones at CERN: Openstack!



We'll gather some data about current Openstack deployments used in production, review some source code from various projects, see some anecdotes from devops people who deploy these systems, and explore the infrastructure and quality assurance processes used to maintain this massive code base.</description><date>2015-11-07</date><start_time>14:50:00</start_time><end_time>15:20:00</end_time><location>Room 1170</location><external_id>58</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016588</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 2:50pm</display_start_time><display_end_time> 3:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446925800</start_time_t><end_time_t>1446927600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679937</url></item><item><id>679938</id><topic>How to Teach Python to a Ten Year Old</topic><description>Everyone can benefit from hearing about Jake's experiences learning Python--what was helpful and what was not! The good and the bad...

 - Things to learn before Python: Snap, Squeak,  Logo, Karel the Robot, Alice, Scratch, Tynker, Trinket

 - Python tools and environments for learning: Codecademy, Code Combat, Code Skulptor

 - Courses:  written tutorials, Coursera, Codecademy</description><date>2015-11-07</date><start_time>15:00:00</start_time><end_time>15:10:00</end_time><location>Room 1160</location><external_id>59</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016617</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:00pm</display_start_time><display_end_time> 3:10pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446926400</start_time_t><end_time_t>1446927000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679938</url></item><item><id>679939</id><topic>Orchestrating a Climate Modeling Data Pipeline</topic><description>In order to run high-resolution regional climate models, it is necessary to interpolate and pre-process large amounts of data from a global climate model at the boundaries of the regional model. Several C and Fortran tools are available in the scientific community to achieve different aspects of this task, but communication between these tools is limited to the filesystem (the program/tool reads input from a file and writes output to a file). In a High Performance Computing (HPC) environment, filesystem access is a bottleneck and temporary files should be avoided.



In this talk I will show how a Python driver module and an in-memory filesystem (RAM disk) can be used to orchestrate the data flow between various tools without creating temporary files on disk and fully automate the entire process.

Except for the first input and the last output step, all file I/O is redirected to the RAM disk. The process can also be parallelized in the Python driver module by distributing different input files to different processes using Python multiprocessing.

The use of this technique leads to a speed-up of 800% compared to traditional methods, and requires no human intervention.



Different input datasets are supported and new datasets can be added easily due to the object oriented implementation: at every stage of the pre-processing pipeline a dataset method can be overloaded and a different tool can be used, depending on the input dataset.

This would not have been possible in a simple scripting language that might otherwise be used to automate such a process.



This module (called PyWPS), is part of the WRF Tools package, a set of Python modules and shell scripts designed to facilitate the operation of a regional climate model (the Weather Research and Forecasting model - WRF) in a HPC environment. It is capable of autonomously running the model over extended periods of time (including automatic crash handling and restarts), automatic pre- and post-processing and archiving.



In the presentation I will first provide some context on regional climate modeling and its computational challenges, before detailing the main design features of the Python WRF pre-processing system (PyWPS).



The package is available on GitHub: https://github.com/aerler/WRF-Tools</description><date>2015-11-07</date><start_time>15:10:00</start_time><end_time>15:20:00</end_time><location>Room 1160</location><external_id>60</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016586</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:10pm</display_start_time><display_end_time> 3:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446927000</start_time_t><end_time_t>1446927600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679939</url></item><item><id>679915</id><topic>Afternoon Break</topic><description>n/a</description><date>2015-11-07</date><start_time>15:20:00</start_time><end_time>15:50:00</end_time><location></location><external_id>33</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:20pm</display_start_time><display_end_time> 3:50pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446927600</start_time_t><end_time_t>1446929400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679915</url></item><item><id>679940</id><topic>RPython: turtles all the way down</topic><description>We'll describe a small Logo-inspired language for communicating with turtles, and talk about the implementation of that language in RPython -- a toolkit for building interpreters for dynamic languages, and part of the PyPy project. 



Of particular interest are the performance characteristics of building the interpreter with RPython instead of running it directly, and where that performance increase originates: RPython's meta-tracing framework creates a custom tracing JIT VM for our interpreter. This gives us compiler-like performance for the cost of an interpreter, which is a pretty great bargain, and stands to permanently alter the dynamics of building dynamic languages.</description><date>2015-11-07</date><start_time>15:50:00</start_time><end_time>16:00:00</end_time><location>Room 1180</location><external_id>61</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016590</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:50pm</display_start_time><display_end_time> 4:00pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446929400</start_time_t><end_time_t>1446930000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679940</url></item><item><id>679943</id><topic>Make Jupyter/IPython Notebook even more magical with cell magic extensions!</topic><description>* My talk will start out with a brief explanation of what Jupyter is (the project formerly known as IPython Notebook) and how to launch it.

* I will demo how to run a few lines of Python in Jupyter, and how to create text cells with Markdown and LaTeX.

* I will then demo some of the built-in 'cell magic' extensions like running bash commands and displaying plots inline.

* I will then show some additional off-the-shelf extensions like the SQL and Graphviz ones, and show how to export a notebook to web-based slides. 

* I will then show how one can build and use a useful new cell magic extension (an interactive HTTP client) in Python, using Jupyter's built-in web-based text editor.</description><date>2015-11-07</date><start_time>15:50:00</start_time><end_time>16:20:00</end_time><location>Room 1160</location><external_id>64</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016589</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:50pm</display_start_time><display_end_time> 4:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446929400</start_time_t><end_time_t>1446931200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679943</url></item><item><id>679944</id><topic>Beyond Configuration Management with SaltStack for Event-Driven Infrastructure</topic><description>Congratulations, you've mastered configuration management. So now what? SaltStack is not just configuration management. Intelligent orchestration and automation will help to optimize your infrastructure allowing the dynamic adjustment of infrastructure resources based on monitored changes and events. Dave will provide an overview and demonstration of SaltStack Beacons to monitor systems and the SaltStack Reactor to orchestrate automated, pre-programmed responses. Now that 3:00 AM text message notifies you that a problem has been fixed instead of calling you into the data center for the rest of the night.</description><date>2015-11-07</date><start_time>15:50:00</start_time><end_time>16:20:00</end_time><location>Room 1170</location><external_id>65</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016592</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:50pm</display_start_time><display_end_time> 4:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446929400</start_time_t><end_time_t>1446931200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679944</url></item><item><id>679964</id><topic>Learn to analyse graphs with graph-tool for fun, fun, and profit!</topic><description>Have you every had an Hard morning and thought to yourself:



Self, why can't I understand the data I have here before me? Why can I not just create a Directed Acyclical Graph and create hierarchies of knowledge from a Wikipedia dump? Self how do I get better at analysing graphical data?



Well you're in luck. We'll get you set up with graph-tool and someone to help guide you to the promised land of linear time.

[Register for this tutorial](https://github.com/pyconca/2015-wiki/wiki/tutorials)</description><date>2015-11-07</date><start_time>15:50:00</start_time><end_time>17:05:00</end_time><location>Tutorial Room 2195</location><external_id>85</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016621</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 3:50pm</display_start_time><display_end_time> 5:05pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446929400</start_time_t><end_time_t>1446933900</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679964</url></item><item><id>679941</id><topic>500 Lines or Less</topic><description>Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.



The Architecture of Open Source Applications (aosabook.org) is a book series that aims to change this. The fourth volume (""500 Lines or Less"", github.com/aosabook/500lines/) contains 20 short examples of canonical programs written and explained by experienced software developers. This talk will give a brief overview of the book, and will explore the most surprising lessons we learned by producing it.</description><date>2015-11-07</date><start_time>16:00:00</start_time><end_time>16:10:00</end_time><location>Room 1180</location><external_id>62</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016585</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 4:00pm</display_start_time><display_end_time> 4:10pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446930000</start_time_t><end_time_t>1446930600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679941</url></item><item><id>679942</id><topic>Data Mining Robots: Using Seaborn and Pandas with the Robot Operating System</topic><description>The Robot Operating System (ROS) is an open-source project that facilitates communication between robotic components such as motors, cameras, and other sensors, and computational nodes such as movement commands and pose estimation. However, acquiring and analysing data from ROS can be a little tricky. In this talk, I will go over a few examples of loading data from saved files and live ROS processes using Python with the Pandas and Seaborn libraries.</description><date>2015-11-07</date><start_time>16:10:00</start_time><end_time>16:20:00</end_time><location>Room 1180</location><external_id>63</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016591</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 4:10pm</display_start_time><display_end_time> 4:20pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446930600</start_time_t><end_time_t>1446931200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679942</url></item><item><id>679945</id><topic>Fraud detection in "real time" with Spark</topic><description>We will explore ways of detecting fraud in a stream of data. In a stream of data we want to make sure that we won't receive too many requests from the same source or we might be curious about finding a specific pattern. 

In this talk we will see how Spark can help us with the help of probabilistic data structures.</description><date>2015-11-07</date><start_time>16:25:00</start_time><end_time>16:55:00</end_time><location>Room 1160</location><external_id>66</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016593</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 4:25pm</display_start_time><display_end_time> 4:55pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446931500</start_time_t><end_time_t>1446933300</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679945</url></item><item><id>679946</id><topic>Immutable Django</topic><description>Stop using the Django ORM for evil and embrace the light of Event Sourcing and Domain Driven Design. Learn how to start thinking about your system's behaviour instead of state all while still leveraging the power of Django's ORM. 



First, learn about the history and philosophy of DDD and Event Sourcing and how it applies to software today.



Next, learn simple patterns of approaching DDD in your application today.



Finally, learn how to use the Django ORM to create a race condition free  Event storage and efficient Read Models.</description><date>2015-11-07</date><start_time>16:25:00</start_time><end_time>16:55:00</end_time><location>Room 1180</location><external_id>67</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016594</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 4:25pm</display_start_time><display_end_time> 4:55pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446931500</start_time_t><end_time_t>1446933300</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679946</url></item><item><id>679947</id><topic>How Wave does Database Sharding with Django</topic><description>Learn how we handle a large amount of data in Django by sharding the data using a developer friendly interface. I'll be talking about what we learned from our initial implementation and sharding style as well as the details we used in implementing a newer system.



First, learn about why we shard, why you probably want to shard, what we originally tried and why it didn't work.



Next, learn about how we re-implemented sharding including the router, unique id generation and all the code that went into the project.



Finally, I'll touch on some of the more advanced topics such as shard re-balancing and dealing with replication lag time.</description><date>2015-11-07</date><start_time>16:25:00</start_time><end_time>16:55:00</end_time><location>Room 1170</location><external_id>68</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016595</speaker_id></speaker_ids><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 4:25pm</display_start_time><display_end_time> 4:55pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446931500</start_time_t><end_time_t>1446933300</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679947</url></item><item><id>679916</id><topic>Closing Messages</topic><description>n/a</description><date>2015-11-07</date><start_time>17:05:00</start_time><end_time>18:15:00</end_time><location>Lobby</location><external_id>34</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Saturday, November 07, 2015</localized_date><localized_short_date>Sat Nov 07</localized_short_date><display_start_time> 5:05pm</display_start_time><display_end_time> 6:15pm</display_end_time><date_t>1446872400</date_t><start_time_t>1446933900</start_time_t><end_time_t>1446938100</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679916</url></item><item><id>679917</id><topic>Breakfast</topic><description>n/a</description><date>2015-11-08</date><start_time>09:00:00</start_time><end_time>10:00:00</end_time><location>Atrium</location><external_id>35</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 9:00am</display_start_time><display_end_time>10:00am</display_end_time><date_t>1446958800</date_t><start_time_t>1446991200</start_time_t><end_time_t>1446994800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679917</url></item><item><id>679918</id><topic>Welcome &amp; Morning Keynote (Cameron Davidson-Pilon)</topic><description>n/a</description><date>2015-11-08</date><start_time>10:00:00</start_time><end_time>11:00:00</end_time><location>Lobby</location><external_id>36</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>10:00am</display_start_time><display_end_time>11:00am</display_end_time><date_t>1446958800</date_t><start_time_t>1446994800</start_time_t><end_time_t>1446998400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679918</url></item><item><id>679948</id><topic>Django Rest Framework: The Good &amp; The Bad</topic><description>Have you ever spent way too much time writing an API, and hoped there was a better way? Well, there is! The Django REST Framework (DRF) is a very generic framework for simplifying the creation of your API. In this talk, we will present how the DRF puts together serializers, validators, views, and everything else together into a flexible tool for creating any kind of REST API you may want. Like any framework, there are certain things it makes difficult to do, and we will talk about the problems we faced and solved while making our API do just what we wanted it to do.</description><date>2015-11-08</date><start_time>11:10:00</start_time><end_time>11:40:00</end_time><location>Room 1130</location><external_id>69</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016596</speaker_id><speaker_id>3016597</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>11:10am</display_start_time><display_end_time>11:40am</display_end_time><date_t>1446958800</date_t><start_time_t>1446999000</start_time_t><end_time_t>1447000800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679948</url></item><item><id>679949</id><topic>Wax On, Wax Off: The Tough Love Guide to Mentoring</topic><description>Everyone has more bugs than they can fix, more features they would like than time to write them. Wouldn't it be great to have some help? The problem is who knows enough about what you know to actually provide help the way you need?



Open Source has lots of fans and supporters, but many newcomers need the warmth of a person caring about their existence to actually turn them into a contributor.



Someone sees you working, is enamoured of what you do and wants to learn. You could break down the steps of what you are doing and get them to follow those steps, that is teaching.



You could recognize the deep inner understanding the is the foundation of your behaviour. You could decide to help someone build such a foundation for themselves. That is mentoring.



Mentoring is helping someone to fail and learn from it. Mentoring is about witnessing someone else's journey, whereever they go, whereever it takes them and saying I'm here, I'm with you, I'm watching. Mentoring is 99% listening.



Mentoring is much more time consuming than teaching. Teaching helps someone learn a skill, mentoring helps someone learn themselves.



Now don't get me wrong, teaching is great and we need teachers and to be taught plus many great teachers can also be mentors. Teaching and mentoring are different.



This talk will discuss mentoring.



Anita will endeavour to share what she has learned about mentoring. She hopes you will take away the ability to recognize the difference between teaching and mentoring. She also hopes that should you decide to mentor you have some resources to help you strengthen your mentoring skills.</description><date>2015-11-08</date><start_time>11:10:00</start_time><end_time>11:40:00</end_time><location>Room 1180</location><external_id>70</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016598</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>11:10am</display_start_time><display_end_time>11:40am</display_end_time><date_t>1446958800</date_t><start_time_t>1446999000</start_time_t><end_time_t>1447000800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679949</url></item><item><id>679970</id><topic>What the FORTRAN is ** Doing in Python</topic><description>Exponentiation is just extended multiplication, or is it? Only up to a point. In reality, Real numbers don't really exist, there are only a finite number of Integers, negative zero is not always the same as positive zero, and Complex numbers really are. All of which make exponentiation both subtle and computationally expensive. A retrospective and prospective of the intricacies of reification of 'number' and the occasional futility of mathematical operations in particular, **.



Use cases and examples of operations and functions related to exponentiation (e.g. power, square root, logarithm, hyperbolic cosine) will be drawn from Python and informed by FORTRAN, C. Implementations within Python will be compared and viewed through the lenses of CPython, NumPy, SciPy, Numba, PyPy, Decimal, Fractions, SymPy and more. 



A guided hands-on tour of the tools and challenges of working with bigger and bigger numbers and really tiny ones, too. We'll be looking under the covers to see what Python really does with numbers and operators by utilizing %timeit, dis, with just a taste of Concrete and Abstract Syntax, down to the underlying C code.



[Register for this tutorial](https://github.com/pyconca/2015-wiki/wiki/tutorials)</description><date>2015-11-08</date><start_time>11:10:00</start_time><end_time>12:40:00</end_time><location>Tutorial Room 2195</location><external_id>92</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016620</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>11:10am</display_start_time><display_end_time>12:40pm</display_end_time><date_t>1446958800</date_t><start_time_t>1446999000</start_time_t><end_time_t>1447004400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679970</url></item><item><id>679950</id><topic>Networks and Innovation: A lot of programming inside</topic><description>Current networks don't have the ability to provision network services quickly and easily.

We need rapid provisioning of network services to virtual machines in a data center environment and improve network visibility and reduced operational costs. 



Software-Defined Networking is a way to start building a more open and dynamic network. It means a network can ramp up or ramp down network resources and adapt to sharp, unpredictable spikes in demand much easier than traditional networks. 



To implement SDN, we use Opendaylight and Mininet (a python library) to rapidly prototype our network and create proof of concepts capable of being demonstrated and proved easily.</description><date>2015-11-08</date><start_time>11:45:00</start_time><end_time>12:15:00</end_time><location>Room 1130</location><external_id>71</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016599</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>11:45am</display_start_time><display_end_time>12:15pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447001100</start_time_t><end_time_t>1447002900</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679950</url></item><item><id>679951</id><topic>An example-led discussion of mocking in Python; when to use it and when not to use it.</topic><description>The talk will introduce the mocking facilities in Python and shows the basics of how to use it. We will then go through a real-life example of mocking a public API (there will be an option of 3 APIs and the audience can choose which one I should work on) to show the library being used in a proper example and considering when its not a good idea to use it.</description><date>2015-11-08</date><start_time>11:45:00</start_time><end_time>12:15:00</end_time><location>Room 1180</location><external_id>72</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016600</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>11:45am</display_start_time><display_end_time>12:15pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447001100</start_time_t><end_time_t>1447002900</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679951</url></item><item><id>679952</id><topic>Building a Django app with Viewflow</topic><description>Some applications, particularity those used in enterprise, have use cases the involve a workflow. Most web frameworks, Django included, don't address this specific need. Developers can build their own, but an ad-hoc approach can be hard to maintain. I'd like to share our experience solving this challenge using the Viewflow library.</description><date>2015-11-08</date><start_time>12:20:00</start_time><end_time>12:30:00</end_time><location>Room 1130</location><external_id>73</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016602</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>12:20pm</display_start_time><display_end_time>12:30pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447003200</start_time_t><end_time_t>1447003800</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679952</url></item><item><id>679955</id><topic>Embrace the singularity</topic><description>Machine Learning has been making fantastic advances lately. Problems of classification, recognition, modelling and prediction are currently being optimized to almost-human-level accuracy. Python is used in many research groups to explore Machine Learning approaches, and provides many libraries that allow novices to code non-trivial networks with minimal work. Large corporations have moved from research to deployment. Machine Learning has proven itself useful, and we seem to be getting tantalisingly close to something that could be a “true” strong A.I. 



But shadowing these achievements there is a rising fear in society that we will open Pandora’s box, that our creation will decide that we need to be eliminated. We cannot dismiss those concerns out-of-hand as our track-record as a profession is littered with cases where we have lacked foresight. We should address the concerns now, before the box is sitting in our hands.



Where are we on the road to creating a strong A.I.? How would we recognize a strong A.I.? What can we currently do with Machine Learning, what are the approaches we currently use, and where are they likely to lead over the next few years?



Are there fundamental missing pieces that prevent a “human-like” strong A.I. from developing? Are there scale or resources standing in the way? What are the (moral) considerations in developing a strong A.I.? What about in shutting one down? What are the threat models involved in “standing up” a strong A.I.? What can be done to mitigate those threats?



This talk may include code samples, for which a passing familiarity with Numpy or Theano might be helpful, but the focus for the discussion will be on the algorithms,  epistemology and how we as programmers should approach our attempt to develop an artificial mind.</description><date>2015-11-08</date><start_time>12:20:00</start_time><end_time>12:50:00</end_time><location>Room 1180</location><external_id>76</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016601</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>12:20pm</display_start_time><display_end_time>12:50pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447003200</start_time_t><end_time_t>1447005000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679955</url></item><item><id>679953</id><topic>Full-stack Django application monitoring with django-watchman</topic><description>Monitoring your websites can be tricky. Many people set up a Pingdom endpoint on their home page, and call it a day; however this doesn't guarantee that all of the back end systems required for a functioning site are actually working.



This talk will dive into how to use django-watchman to enhance your monitoring coverage. Topics include:



* How to install and configure django-watchman

* What monitoring checks it provides out of the box

* How authentication works

* The three ways to use django-watchman: API, dashboard, and management command

* How to integrate django-watchman with automated tools like Pingdom

* How to write your own custom django-watchman checks</description><date>2015-11-08</date><start_time>12:30:00</start_time><end_time>12:40:00</end_time><location>Room 1130</location><external_id>74</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016603</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>12:30pm</display_start_time><display_end_time>12:40pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447003800</start_time_t><end_time_t>1447004400</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679953</url></item><item><id>679954</id><topic>Django and the joys and benefits of live coding</topic><description>With the rise of live video streaming, such as Periscope for social and Twitch/Youtube for gaming, there has been a rise in the interest in sharing what you're currently doing with the world as well as also interacting with those people who choose to watch what you're streaming. One of the biggest problems with learning and/or improving your programming abilities is not always being able to get instant feedback on demand or having others provide helpful suggestions instantly. Bring forth a platform that allows programmers to share their projects live and interact with those viewing their stream, LiveCoding.tv.



Django and the joys and benefits of live coding seeks to cover Wesley's most recent Bitcoin project that was built solely while streaming with LiveCoding.tv. Django and the joys and benefits of live coding will cover the basics of Wesley's project as well as the trials, tribulations, pros and cons of building a project live in front of people from all over the globe, all walks of life, all programming backgrounds and skill levels.



If you're looking for a platform where you can help others, get help from other, watch other create projects or just socialize in real time with other programmers Django and the joys and benefits of live coding is a talk for you.</description><date>2015-11-08</date><start_time>12:40:00</start_time><end_time>12:50:00</end_time><location>Room 1130</location><external_id>75</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016604</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>12:40pm</display_start_time><display_end_time>12:50pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447004400</start_time_t><end_time_t>1447005000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679954</url></item><item><id>679919</id><topic>Lunch</topic><description>n/a</description><date>2015-11-08</date><start_time>12:50:00</start_time><end_time>14:00:00</end_time><location>Atrium</location><external_id>37</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time>12:50pm</display_start_time><display_end_time> 2:00pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447005000</start_time_t><end_time_t>1447009200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679919</url></item><item><id>679965</id><topic>From Flying Circus to Holy Grail: Migrating the Twilio REST API from PHP to Python</topic><description>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. Over time, core business logic has been extracted from the legacy codebase into internal services fronted by a public REST API. This talk will explore how Python and Flask were used to build a simple proxying HTTP layer to handle all of Twilio’s API traffic and direct it to the appropriate internal systems. Along the way, we’ll cover why Python is well-suited to this application, ways to test code that’s replacing existing services, deployment strategies, and all of the benefits that came from migrating to more modern systems.</description><date>2015-11-08</date><start_time>14:00:00</start_time><end_time>14:30:00</end_time><location>Room 1130</location><external_id>86</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016605</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 2:00pm</display_start_time><display_end_time> 2:30pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447009200</start_time_t><end_time_t>1447011000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679965</url></item><item><id>679966</id><topic>Using Python for Real Time Signal Analysis</topic><description>The main subject of this talk is how Python can be used as an alternative to the more commonly used high-level languages used in the scientific data analysis industry.



This talk will focus on PyRF, an open-source library developed by ThinkRF, and how it has been used to provide the same functionality in terms of instrumentation control, data acquisition, digital signal processing, automated testing, production testing, as well as application development.</description><date>2015-11-08</date><start_time>14:00:00</start_time><end_time>14:30:00</end_time><location>Room 1180</location><external_id>87</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016606</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 2:00pm</display_start_time><display_end_time> 2:30pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447009200</start_time_t><end_time_t>1447011000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679966</url></item><item><id>679956</id><topic>Working effectively with legacy code -- Python edition</topic><description>Working effectively with legacy code - Python Edition



Legacy code is that terrifying monster lurking in almost every long-lived codebase. You may not understand it, you may wonder how it works at all! It is the type of code most developers do their best to stay away from, and for good reason. So what is there to do when you inherit such a system for the first time? How can you take it from unknown mess to gleaming example of excellent engineering? What is unique about legacy systems written in Python?



This talk will present a series of tools, both technical and social, for rehabilitating unknown, untested, and maybe even unloved systems. Approaches to improving these systems will primarily focus on refactoring and testing, with sidebars on engineering culture and personal motivation. We will reference Michael Feathers's excellent book on the topic, but also depart significantly to discuss particular challenges and opportunities presented by the Python language. After all, much of the written literature on this topic assumes a fairly Java-centric view of the world, and offers little support when you realize that object you thought was a dict is actually an ORM model that just happens to support getattr lookup.



The intended audience is someone relatively new to professional programming, who is encountering their first legacy codebase. This talk will be a crash course in how to handle your unknown adversary.</description><date>2015-11-08</date><start_time>14:35:00</start_time><end_time>15:05:00</end_time><location>Room 1130</location><external_id>77</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016607</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 2:35pm</display_start_time><display_end_time> 3:05pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447011300</start_time_t><end_time_t>1447013100</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679956</url></item><item><id>679957</id><topic>Python for reliable delivery of cross platform developer products</topic><description>Are you part of a team responsible for delivering cross platform products? End to end automated testing and communicating effectively are important when your project depends on multiple teams spread across functional domains. At Braintree/PayPal, we built a framework to reliably ship developer facing products such as One Touch. In this talk, we will go over using BDD with Behave to describe test scenarios that speaks to both product and engineering, using Appium for mobile automation, and Elasicsearch and Kibana for storage and visualization of test results. You will see how the breadth of packages available on PyPI, the flexibility and ease of Python helped a team of developers whose core competencies were not in Python to collaborate on a common ground.



Only beginner Python knowledge is necessary but an appreciation for the breadth of possibilities with Python is highly encouraged.</description><date>2015-11-08</date><start_time>14:35:00</start_time><end_time>15:05:00</end_time><location>Room 1180</location><external_id>78</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016608</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 2:35pm</display_start_time><display_end_time> 3:05pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447011300</start_time_t><end_time_t>1447013100</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679957</url></item><item><id>679959</id><topic>An example of scikit-learn and SciPy used for the analysis of extreme weather</topic><description>There is considerable interest in the effect of climate change on extreme weather in the scientific community and in the public. However, detecting changes in extreme weather events in the observational record is extremely difficult, because extreme events are by definition rare and the instrumental record is not long enough to establish robust statistics for a single station record.



In this talk I show how tools from the scientific Python software stack can be used to analyze precipitation (rainfall) data and overcome this problem and detect changes in the observational record.



The analysis proceeds in two stages: first a k-means clustering algorithm (sklearn.cluster) is used to aggregate data from different stations that have similar climatological characteristics, and then a theoretical distribution function is fitted to the data (scipy.stats).

The first step increases the number of data points to constrain the fit in the second step, assuming all stations in the same cluster have the same underlying distribution. The second step serves to further reduce noise and extrapolate the distribution to the most extreme quantiles.

Finally a statistical test (scipy.stats) can be used to detect changes and asses statistical significance.



I will introduce the analysis algorithm using historical data from meteorological stations (Environment Canada), but I will also show how this technique can be applied to climate model projections of future climate change.



The analysis was conducted using the GeoPy analysis package, which is described in a separate talk. The package is available on GitHub: https://github.com/aerler/GeoPy

An extended abstract submitted to the Climate Informatics workshop in Boulder (September 24-25, 2015; 2 pages) is available here: http://www.physics.utoronto.ca/~aerler/files/presentations/ci2015.pdf</description><date>2015-11-08</date><start_time>15:10:00</start_time><end_time>15:20:00</end_time><location>Room 1180</location><external_id>80</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016586</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 3:10pm</display_start_time><display_end_time> 3:20pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447013400</start_time_t><end_time_t>1447014000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679959</url></item><item><id>679958</id><topic>Python for command line tools, up and down of Mercurial language of choice</topic><description>In 2005, Matt Mackall picked Python to implement a new version control system: Mercurial. Ten years later, the project is a success! Thanks to python? Lets see what shinning advantages met us and what issues we, developers, had to work around. We'll also take a detour to the place were python outcrop to the users, the extensions system.



In 2005, Matt Mackall picked Python to implement a new version control system: Mercurial. Ten years later, the project is a success! Thanks to python?



In this Talk, we'll go over on the advantages of Python that helped the project both in its early life when so much feature needs to be implemented, but also nowaday when major companies like Facebook bet on Mercurial for scaling. We'll also point at the drawback of choosing python and how some work-arounds had to be found. Finally, we'll look at how the choice of python have an impact on the user too with a demonstration of the extensions system.</description><date>2015-11-08</date><start_time>15:10:00</start_time><end_time>15:40:00</end_time><location>Room 1130</location><external_id>79</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016609</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 3:10pm</display_start_time><display_end_time> 3:40pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447013400</start_time_t><end_time_t>1447015200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679958</url></item><item><id>679967</id><topic>Python GUI tools for editing initial and boundary conditions for climate simulations</topic><description>Researchers working in the fields of atmospheric sciences and earth sciences often have to modify gridded data at select points as part of their research workflow. This could be because they want to manually fix spurious artifacts, or more commonly because they want to generate custom initial and boundary conditions for climate simulations. The typical researcher would accomplish making the changes by specifying the grid points to change within a script (shell script, python script, NCL script etc.) and then repeat this iteratively until all the changes have been made. This process is not only time consuming and inefficient, but it is also prone to errors that might be introduced if the wrong grid points are accidentally specified. In this talk, we describe a collection of open source graphical programs written in python and built upon the PyQt and matplotlib libraries that expose a very efficient and informative interface to modifying boundary conditions for climate simulations to be performed with the widely used Community Earth System Model (CESM). With these portable programs the effort required by a researcher to modify boundary conditions for a new simulation is greatly reduced. The visual editing also ensures that the researcher is always sure that she is editing the grid points she intends to change. Finally, although the programs were created for a specific purpose, for a specific climate model, they can be nevertheless readily adapted to suit the needs of other researchers.</description><date>2015-11-08</date><start_time>15:20:00</start_time><end_time>15:30:00</end_time><location>Room 1180</location><external_id>88</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016610</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 3:20pm</display_start_time><display_end_time> 3:30pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447014000</start_time_t><end_time_t>1447014600</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679967</url></item><item><id>679968</id><topic>Bioacoustics in Python</topic><description>Certain species of bark beetle, such as the mountain pine beetle, have a devastating effect on forests across North America. They have been called “the greatest tree killers known” and their economic impact is measured in the billions. Not all bark beetles are destructive, though, and research is currently being done on using their acoustic signals to identify their species. 

 

Python provides an excellent platform for exploring this costly ecological problem. This talk will look at:



 - how libraries such as LibROSA can be used to analyze the audio recordings;

 - how numpy, scipy and pandas can be used to extract features;

 - and how machine learning algorithms from scikit-learn can then be applied to build a classifier.</description><date>2015-11-08</date><start_time>15:30:00</start_time><end_time>15:40:00</end_time><location>Room 1180</location><external_id>89</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016611</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 3:30pm</display_start_time><display_end_time> 3:40pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447014600</start_time_t><end_time_t>1447015200</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679968</url></item><item><id>679960</id><topic>Fabric-less Deployments for WSGI Apps</topic><description>Intermediate level talk about migrating a Fabric deployment to a more flexible setup using using Ansible and Invoke. Follows the journey of changing the deployment of a Flask based blogging app from a Fabric script and pre-provisioned server to a modular system with Invoke tasks and provisioning using Ansible. Discusses the advantages and cons of moving to a declarative system versus direct shell commands. Touches upon on Ansible Roles, Ansible Galaxy and Invoke.</description><date>2015-11-08</date><start_time>15:45:00</start_time><end_time>16:15:00</end_time><location>Room 1130</location><external_id>81</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016612</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 3:45pm</display_start_time><display_end_time> 4:15pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447015500</start_time_t><end_time_t>1447017300</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679960</url></item><item><id>679961</id><topic>Learning to Code... Better!</topic><description>I came to coding by a circuitous route that started with studying logic within philosophy. Along the way, I've tackled a number of subjects related to learning and skill development - from a philosophical, practical, sociological and educational standpoint - and I thought, what better way to test the things I've come away with in action than to put them to work for me as I start to learn how to code. 



I’ll be providing a brief summary of the what and why of things that worked and things that didn't work to help me learn and become a better coder as I started teaching myself, and continue leaning, Python. Rather than focusing on issues that are aimed at beginners, I want to zero in on a few points that I want to take into my late coding career and so will be helpful to a broader audience as they are picking up newer technologies. I'll quickly move through things like mapping out code before writing it, being efficient and descriptive, how to deal with failure when it inevitably happens, contrarianism in the coding community, how to ""stick to it"", Googling, dealing with the peaks and valleys of daily coding, ego and code, pacing yourself, taking 'productive' breaks, and how to gauge improvement.</description><date>2015-11-08</date><start_time>15:45:00</start_time><end_time>16:15:00</end_time><location>Room 1180</location><external_id>82</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids><speaker_id>3016613</speaker_id></speaker_ids><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 3:45pm</display_start_time><display_end_time> 4:15pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447015500</start_time_t><end_time_t>1447017300</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679961</url></item><item><id>679920</id><topic>Closing Ceremonies</topic><description>n/a</description><date>2015-11-08</date><start_time>16:25:00</start_time><end_time>17:00:00</end_time><location>Lobby</location><external_id>38</external_id><section_id>125690</section_id><allow_ask_a_question>0</allow_ask_a_question><group_ids/><speaker_ids/><polls/><localized_date>Sunday, November 08, 2015</localized_date><localized_short_date>Sun Nov 08</localized_short_date><display_start_time> 4:25pm</display_start_time><display_end_time> 5:00pm</display_end_time><date_t>1446958800</date_t><start_time_t>1447017900</start_time_t><end_time_t>1447020000</end_time_t><url>http://api.eventmobi.com/en/api/v1/events/PYCONCA2015/sections/125690/items/679920</url></item></items><config><track_view_default>0</track_view_default><session_tracks_name>Tracks</session_tracks_name><hide_favourite_buttons>0</hide_favourite_buttons></config></response><timestamp>1446076646</timestamp>
</data>