pre-release: Kiwi PyCon meeting announcement
Please take a moment to review your details and reply with OK or edits.
Subject and below is what will go out and also will be used to title the videos.
Subject:
ANN: Kiwi PyCon at C1 Fri September 4, 10:30p
Kiwi PyCon
=========================
When: 10:30 AM Friday September 4, 2015
Where: C1
https://nzpug.org/schedule/schedule.json
https://nzpug.org
Topics
------
1. Introduction to Data Processing with Python
Lilly Ryan
This tutorial follows on from our "Introduction to Programming with Python" workshop. You don’t need to have participated in this workshop before, but you will need to know some basic programming in Python. If you’re not sure, you can check out our introductory workshop here: http://opentechschool.github.io/python-beginners/en/
Participants work at their own pace following the OpenTechSchool course material here: http://opentechschool.github.io/python-data-intro/
Chatting among participants is encouraged in order to empower everyone to discover the joy of programming for themselves, but experienced coaches will be on hand to help whenever a participant gets stuck.
Depending on the individual participant, this workshop can take up to three or four hours, but as the material we provide is free and open-source, you are welcome to take it home with you to continue on your own.
recording release: yes license: CC BY-SA
2. Python Introduction for non-Programmers
Grant Paton-Simpson
### Course Objective
Python was designed with a simple syntax. Clean, readable code is the norm in Python, not the exception.
This training session will introduce you to Python syntax and philosophy. You will learn about Python, and
have plenty of opportunity to put it into practice. If you have little to no prior experience in programming this
course is for you.
By the end of the course you will be able to write some basic Python scripts. You should also have a
foundation of ideas which makes it easier to learn further Python skills.
### Course Content
* Coding culture – being “Pythonic”
* Running your code
* Variables
* Basic syntax, data types, and control structures
* Built-in documentation
* Functions
* The standard library (“batteries included”)
### Prerequisites
There are no prerequisites for this course – just enthusiasm.
recording release: no
3. Introduction to SaltStack
Aurynn Shaw
# An Introduction to SaltStack
SaltStack is a powerful RPC-based configuration management system written in Python, and in this tutorial students will be introduced to the core concepts of SaltStack, the data management model, and the client-server infrastructure in Salt.
From a provided SaltStack server VM, we will implement a simple single-server environment using Vagrant and Virtualbox, expand our installation to a multi-server with different roles, and explore the use of Jinja templating as part of the Salt configuration system.
Students will need:
- A laptop
- Virtualbox 4.3.30 or 5.0
- Vagrant version 1.7.3 or higher
- The *ubuntu/trusty64* vagrant base box
Students are encouraged to register.
A base SaltStack server VM will be provided, and will be the basis of the tutorial.
recording release: yes license: CC BY-SA
4. Web Scraping
Yuriy Ackermann
In this tutorial you will learn how to do website parsing and use the gather data in your application. Sometimes it's really difficult to get data out of a website, because it does not offer an API or the data we are after are scrambled across multiple web pages. If you want to learn how programmatically to solve this problem register for this tutorial.
Requirement:
- Python 3
- BeautifulSoup4 (pip3 install beautifulsoup4)
- Big smile *)
P.S. Prizes included.
recording release: yes license: CC BY-SA
5. Introduction to Python
Lilly Ryan
This workshop will take participants through the very basics of programming using Python, including an introduction to the command line. No previous programming experience is required!
Students work at their own pace following the OpenTechSchool course material here: http://opentechschool.github.io/python-beginners/en/index.html
Chatting among participants is encouraged in order to empower everyone to discover the joy of programming for themselves, but experienced coaches will be on hand to help whenever a participant gets stuck.
Depending on the individual participant, this workshop can take up to three or four hours, but as the material we provide is free and open-source, you are welcome to take it home with you to continue on your own.
This tutorial is a precursor to our "Introduction to Data Processing with Python" workshop.
recording release: yes license: CC BY-SA
6. Python Introduction for Developers
Grant Paton-Simpson
### About the course
Depending on your programming background, aspects of Python will either seem very familiar, slightly different, or completely alien. This course will clarify the main features of Python's syntax and ecosystem with special attention to aspects that may be surprising to non-Python developers.
### Course Outline
* Python as a Language
* Data Types (numbers, strings, lists,
* dictionaries, tuples, misc)
* Conditionals
* Simple Functions
* Names and Values
* Scope
* Loops
* Idiomatic Python
* Gotchas
* Modules
* Exceptions
* Classes/Objects
* Standard Library
### Target Audience
Those who currently program in other languages and wish to learn about how Python works and what can be done with it.
### Prerequisites
Familiarity with at least one other programming language is required.
recording release: no
7. Connascence in Python
Thomi Richards
Connascence is the taxonomy of coupling: it allows us to specify how two or more pieces of code are connected, and suggests ways of minimising the impact of that coupling. Ultimately this allows developers to write software that is more flexible to change.
At the end of the talk the audience will have learned some of the forms of connascence with real python code examples, and will understand how to apply those principles to their own code.
recording release: yes license: CC BY-SA
8. Cython: get the benefits of C without leaving Python
Chris LeBlanc
Cython is an optimising static compiler based on Pyrex, created by Greg Ewing from the university of Canterbury. It bridges the worlds of Python and C, letting you write code that runs close to C speed in a syntax that is very close to Python. This talk will show how you can speed up a typical Python program with Cython datatypes. We’ll call C functions directly, passing NumPy arrays with ease. We’ll see how we can release the global interpreter lock, letting us run multiple threads in parallel near C speeds. We’ll look at Cython’s parallel module for data parallelism and compare it to some alternatives and discuss the pros and cons.
recording release: yes license: CC BY-SA
9. A practical guide to web security
Jeremy Stott
This presentation is an introduction to securing your Python web application. I am definitely not a security expert, just a developer who thinks security should be everyone's job. That's right. It's your responsibility too. Hopefully I can soften the blow by giving you a beginner's guide to security. That's me, the beginner.
We will pick apart an example Python web application to demonstrate good security practices, along with examples and explanations of why they are important.
I'll cover a few different web security topics:
* Not trusting any input from your users
* Authentication and session management
* Using HTTPS effectively
* Things not to do in client land
* Obvious mistakes
* Not so obvious mistakes
If you have written a web application and not thought twice about security, this talk is for you. If you can name the OWASP Top 10, then you can come along anyway and ask me a really tricky question at the end.
recording release: yes license: CC BY-SA
10. Python and Elasticsearch (Add Full Text Search to your legacy application)
Benoit Chabord
At GrabOne we started to use Elasticsearch a year ago and integrate it with Django. The transition was pretty smooth.
## What Is Elasticsearch ?
* Open Source product https://www.elastic.co/products/elasticsearch
* Based on Apache Lucene index system
* Dristibuted, scalable and highly available
* Real time search and analytics capabilities
* RESTful API
## Integration With Python
* Because it is RESTful can be integrated with urllib
* Official Python connector maintained by the elasticsearch team https://github.com/elastic/elasticsearch-py
* Official Pythonic Query builder and Model mapper (ORM) https://github.com/elastic/elasticsearch-dsl-py
## GrabOne use case
* Started by redoing the search page
* Rebuilding the entire frontend using Elasticsearch as datasource for a Django website
recording release: yes license: CC BY-SA
11. Python in Classrooms
Martin Henschke, Eloise "Ducky" Macdonald-Meyer
Python as a language has had great success in being accessible to aspiring programmers of much younger ages than most contemporary languages, and the skill set attained from learning to program may include basic problem solving, mathematics and even literacy. We have conducted several workshops with diverse groups of primary school children in years 4 to 6, attempting to teach elementary programming skills using Python. The goals of the workshops were to promote numeracy and literacy in Tasmanian schools, where there may be lower rates of competency in these areas. We wanted to do this through the use of a formal, syntax-dependent language, which could have benefits related to natural language skills and literacy. To engage our students we constructed exercises in different topics, that lead to children being able to modify a small, simple and modular game using PyGame for Python 2.7. In some of these exercises, the students created elementary programs to answer simple math questions and participated in group exercises to make modifications to one version of the game (adding characters, dialogue and interactions) before being able to modify their own version. In these sessions we found participants to engage well with the source material despite being reasonably advanced, with teaching staff making comparisons between accurate python syntax and grammatically correct English.
recording release: yes license: CC BY-SA
12. Functionalish programming in pip with effect
Robert Collins
'everyone' knows that separating out IO and other side effects makes code easier to unit test. What if there were a Python library that helps do that systematically which you could use to make all your things better? There is. Come and find out more.
Chris Armstrong's Effect library is the library in question. I found this while digging into all the varied implementations of monads for Python (a generic concept that encapsulates the principle of IO and side effects) - and I'd like to share its beauty with other folk. Effect (https://pypi.python.org/pypi/effect) allows consistent separation of side effect (e.g. IO or even just global state changes) from the code that depends on those effects. Testing and reasoning about code becomes easier. But it can often be hard to get into such a system. Allow me to take you on a tour through how to change regular code into super testable code using Effect.
recording release: yes license: CC BY-SA
13. WX Python Tuning Application For FreeEMS
Dana Garifullina, Fred Cooke
Wait, what is FreeEMS and other non-familiar things you just talked about?*
What's this FreeEMS thing, exactly? FreeEMS is an open sauce standalone engine control system used on more than 30 vehicles in 11 countries around the world. Tuning application is a tool used to adjust configuration and calibration data in an embedded software system known as a standalone. And what about standalone? A standalone is a specialised computer that measures and controls the operating parameters of an internal combustion engine. The most common commercial example was developed right here in Christchurch and is called Link. Yay!
*What's wrong with old one?*
Python tuner written by Aaron Barnes for FreeEMS founder Fred Cooke in 2008-2010 is beautiful and awesome GUI which needs to be resurrected by updating protocol, improving some essential features and giving new abilities. FreeEMS community is in search for good and reliable tuner, I'm keen to learn more about cars and achieve and share my first experience GUI developing. Kach-ing! Perfect exchange.
*What's the plan, Stan?*
1. FreeEMS essentials and glorious story briefly, introduction with Fred Cooke.
2. Briefly about wx-python typical application, threading with examples from python tuner.
3. Tuner architecture, what's done to make it awesome, what's need to be done, future plans.
*Okay, you got me!*
Yep, and specially for you, my dear car geek, you will hopefully have a chance to have a look/try how whole system works with car and see it alive after talk!
recording release: yes license: CC BY-SA
14. Message Passing Interface and Inversion of Control
Rand Huso
The myriad of methods available for MPI programming is daunting by itself, and largely unnecessary. The solutions proposed by the developers of MPI and the new languages in this space are all addressing the problem the way it's always been addressed. What I present is a way to attack the massively parallel problem that reduces the complexity of MPI programming to that of implementing a very simple state machine. I've used this combination of MPI and IoC to write state-of-the-art applications that run on some of the largest supercomputers around the world.
recording release: yes license: CC BY-SA
15. Integrating Python Apps with Centralised Identity Management Systems
Fraser Tweedale
Most Python web developers are familiar with authentication and
authorisation on the open web, but the requirements and technologies
used inside companies and large organisations are different:
* Identities and groups are probably stored in an external identity
management system's directory rather than in an application's
database tables.
* Authorisation decisions will be based on group membership and
policies that are defined outside the application.
* Users may be expected or required to use a *single sign-on*
technology such as Kerberos or SAML to authenticate to
applications.
This talk will familiarise the audience with these technologies and
demonstrate how Python web applications can be integrated with an
identity management system to meet business requirements while
providing a positive user experience. Particular technologies
covered will include:
* [FreeIPA](https://www.freeipa.org): an open-source identity
management solution, for defining users, groups and authorisation
policies
* [mod_auth_gssapi](https://github.com/modauthgssapi/mod_auth_gssapi) /
mod_auth_kerb: Apache modules for Kerberos authentication
* [mod_lookup_identity](http://www.adelton.com/apache/mod_lookup_identity/): Apache
module to retrieve user information from a directory
The talk will conclude with discussion about upcoming Kerberos
features, techniques for dealing with multiple authentication
methods, and progress in making identity management integration
easier for Python (and in particular, Django) developers.
People developing or deploying Python web applications in business
environments or for large open source projects with centralised
identity management will get the most out of this talk.
recording release: yes license: CC BY-SA
16. An introduction to Wagtail (CMS)
Eloise "Ducky" Macdonald-Meyer
This talk is an introduction to Wagtail, a content management system built on the Python web framework, Django. Many content managers are not designed with web developers in mind, and choosing the right CMS for a project, that does it's job well and assists with fast paced development, can be difficult. Everyone has a favourite out there. I'm not sure if I can call Wagtail my favourite yet, however I have found it to be a very developer-friendly system. And after unknowingly working alongside a core contributor for some time, I hadn't realised what little recognition Wagtail has as a tool, even among Django developers. My talk will thus discuss the pros and cons of the system, with a demonstration to show how easy it is to get started with using it. I will also touch on it's nature as an open-source platform and some of it's potential futures.
recording release: yes license: CC BY-SA
17. Build a Better Hat Rack: All Contributions Welcome
Katie McLaughlin
We have many ways of reporting and recognising our code contributions in open source projects, but often it is the work we do outside of code commits themselves that get forgotten and unattributed. Hours of code review, documentation, testing; organising of meetups and volunteering at conferences; even just brainstorming and talking about things - how much of these have you done without accreditation?
During this session, we will discuss what it means to contribute to open source projects, what constitutes a non-code contribution, steps we can take to recognise the work of our peers, and how projects can better encourage non-code participation through recognition and acknowledgement.
recording release: yes license: CC BY-SA
18. My own Platform as a Service in Python, which you can do too
Lee Begg
Over the last couple of years I have evolved my own Platform as a Service (PaaS) for hosting Django apps, and you can run it too.
I use Nginx, Circus, Chaussette, and Django, with some support from Django-environ and deployment automation using Fabric. All of that except Nginx are written in Python. Systemd is a new init process coming.
* Circus is a process and socket manager, and gives a nice way to scale processes.
* Chaussette WSGI server works well with Circus, as Circus can pass the socket to it.
* Django-environ it's a library that parses environment variables or files with key-value pairs. Environment variables are used on some PaaS, but the file support I find very useful.
* Fabric is a framework for writing system commands to be run on remote hosts, and is great for automating system administration.
* Systemd is a new "init" process for Linux and offers some interesting possibilities for hosting Python webapps.
recording release: yes license: CC BY-SA
19. Micro-Services: Is HTTP the only way?
Ben Shaw
Introduction
============
Over the past few years, micro-services have been gaining popularity due to their advantages over traditional monolithic architectures. It becomes easier to horizontally scale the heavier portions of an application; you're not tied to the same OS or programming language for the entire application, meaning you can easily slot in the best tool for the job; and finally, you can quickly build the entire application in dynamic yet less performant languages, then rebuild any bottlenecks with faster (but slower to develop) languages.
As a basic example, rather than directly communicating with a database for user authentication, a web front-end would make an HTTP request to another lightweight REST service to check credentials.
An Example Application
======================
In order to elucidate the difference between monolithic and micro-services, we will use a simple Social-Network web application that allows users to post 141 character messages. A user must first sign up, then log in with a username and password, then they can post their messages publicly. A user can then follow any other user, and receive real time updates when that user posts. While the behaviour is simple, there are a number of different concepts that are explored: template rendering, user signup and authentication, data storage and notification delegation.
A Monolithic Version
======================
The first version of the will be a single Django application. The talk does not go into detail on the source code, instead briefly discusses the views, databases (tables and queries) and overall architecture at a high level.
The HTTP Micro-Service Version
===============================
In order to deconstruct the monolith into micro-services, we look at different functions of the application: message viewing, user signup and authentication, data storage and search, and user notification. Django is kept as the front-end, but the databases for authentication, data storage and searching and user-follows are each transformed into their own micro-service. Flask is used as the HTTP framework for these services, with SQLAlchemy for database as necessary. Some source code is discussed (mostly in terms of standard Django database access c.f. HTTP) but this is also quite high level. The talk will also cover what HTTP comes with "out of the box", in terms of authentication, deployment and scalability.
Alternative Transports
======================
After the micro-services have been split, we can start to think about different transports that might be more appropriate (or at least more interesting) in some circumstances.
Introducing a Message Queue
---------------------------
From a user perspective, HTTP is a synchronous protocol, so making other synchronous HTTP calls inside an HTTP handler doesn't introduce much complexity. Message queues, on the other hand, are asynchronous by nature. We look at using message queues for delegating user notifications (which don't require a response, and are easy to handle), then for authentication, data storage and searching – each requiring a slightly different "level" of "synchronicity" and a need to be shoehorned into HTTP differently. We'll look at code for message producing and consuming and discuss architecture again.
Message queues are already widely used for handling intensive background tasks, so we'll look at how they compare to HTTP in this application (for security and deployment), and briefly also talk about cross-platform compatibility.
Lower Down the Stack - Raw Sockets
----------------------------------
If, for some reason, the overhead of HTTP or a message queue is too high, direct socket communication might be better. We'll look at a Python TCP server for user authentication, and a UDP server for handling user notifications, and example code for both. Also discussed are the security implications (it's DIY all the way), performance, and how you might scale these.
Conclusion
==========
Finally we'll look at a comparison overview for all these different methods and summarise with the pros and cons of each.
recording release: yes license: CC BY-SA
20. Why Python is awesome – and some other languages are cool too
Lee Symes
Switching between many languages quickly clarifies each language's strengths and weaknesses. My background is in Java – however more recently I have moved onto using Python, JavaScript and PHP, whilst dabbling in Go. My talk will cover:
- Asynchronous programming, and the various ways it can be written in code, with reference to JavaScript and Go.
- Packaging, how some languages do it better and worse than Python, and what Python can learn from them.
- Unit testing in all languages is hard, but the syntactic sugar that is added can ease the pain, and make the output when your tests inevitably fail easier to read.
- Syntax Shock, what brackets and semi-colons? Why are you not running – oh yes I need a semi-colon there.
- Cool stuff with Magic(al) methods and Duck Typing that languages like Java would not have a hope of implementing.
This talk will highlight some of the delight I get when coming back to Python; and some of the aspects of other languages that I think would be really cool to add.
recording release: yes license: CC BY-SA
21. You Don’t Care About Efficiency: Synchronous Code Is Dying
Cory Benfield
If you write blocking code, you don’t care about efficiency.
There, I said it.
It’s 2015, and still the vast majority of Python programmers write essentially synchronous code that blocks on network I/O. This approach, while simple to reason about, struggles mightily with scaling up and out into software that does a lot of network I/O. Worse, it makes it difficult to write code that reacts rapidly to changing conditions.
The writing is on the wall for this kind of software, as the community shifts towards writing software that embraces asynchronicity. In this talk we’ll discuss why synchronous software is a problem, what your options are to move away from it, and what challenges are being faced by the Python ecosystem as we try to move towards a brave new asynchronous world.
recording release: yes license: CC BY-SA
22. Using Python to Test
Kieran Brownlees
This talk has very little to do with what most people associate with testing, and everything to do with the challenges, tools and concepts required to perform large scale automated testing of hardware devices. I promise there will no mention of the difference between unit and integration tests.
recording release: yes license: CC BY-SA
23. Custom Python Applications in Neuroscience
Gagan Sharma, Simon Salinas
There are several (open source and proprietary) packages available for image processing in neuroscience. However, each package has its own strengths and limitations depending on the purpose of the analysis. After testing many of them at work, we have found a need to develop our own packages (at the Brain Imaging Laboratory, MBC). We will expose a couple of python tools that could be handy for anyone dealing with neuroscience (or medical images in general) in their projects. The tools presented are for (i.) quick image viewing, (ii.) dicom image sorting and de-identifying and (iii.) automatic email notifications to alert about server warnings (e.g., if machine is down, close to full capacity, failing to connect to local image archiving network (PACS), etc..). While many of these tools could have been written in other programming languages, we will explain the reasons for choosing python, share a bit about our python learning journey and perform a brief demonstration on the command line.
recording release: yes license: CC BY-SA
24. Zaqar: Message and Notification service of OpenStack
Fei Long Wang
As every messaging service, it's main goals are:- performance, availability, durability, fault-tolerance and scalability. Besides providing support for message and notification services through OpenStack, Zaqar aims to ease the design of distributed systems and allow for asynchronous work distribution without creating yet another message broker.
This talk aims to give the audience as much information as possible about Zaqar's architecture, design, patterns, performance, issues it faced and how why it was built from scratch.
recording release: yes license: CC BY-SA
25. Database migrations using alembic
Tim Mitchell
Managing database schema changes can be a challenging process. From the schema change itself to keeping test (and user!) data in sync with the schema across multiple development branches can be a headache. Alembic is paracetamol for this change management headache. Alembic is a companion package to sqlalchemy for creating database schema migrations. This talk will introduce alembic, demonstrate how it is used to generate schema deltas and migrate database schemas. The talk will discuss manually adding data migration to a schema migration script and describe how using alembic has changed our development process. Some familiarity with databases and sqlalchemy will be assumed.
recording release: yes license: CC BY-SA
26. The Pythonista's 3D printing toolchain
Steve Baker
[SolidPython](https://github.com/SolidCode/SolidPython) is a Python module which allows executed Python to generate OpenSCAD script. [OpenSCAD](http://www.openscad.org/) is software for creating solid 3D CAD models. OpenSCAD is not an interactive modeller, instead it is something like a 3D-compiler that reads in a script file that describes the object and renders the 3D model from this script file.
[Cura](https://github.com/daid/Cura) is the Python-based user interface to the CuraEngine slicing library, which processes 3D models into 3D printing instructions for various printers.
[BotQueue](https://www.botqueue.com/) is a 3D printing job-control service, allowing remote submission and monitoring of printing jobs to any number of printers.
This talk will take a tour through SolidPython, Cura, and BotQueue showing how Python can help with the design, preparation, and printing of your doodad, widget, or dingus.
recording release: yes license: CC BY-SA
27. Python's New Type Hints in Action… In JavaScript
Christopher Neugebauer
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.
recording release: yes license: CC BY-SA
28. Mezzanine: a brief primer
Will Hughes
Mezzanine is a CMS framework built on top of Django that provides a set of primitives for building rich sites that can be managed by non-technical users.
Topics this talk will cover:
* Where Mezzanine sits in the broader ecosystem.
Mezzanine is not a stand-alone product like Drupal or Wordpress, but a set of tools. There are other tools associated with Mezzanine that provide functionality that Mezzanine itself doesn't provide
* Structure of a Mezzanine site
* Two techniques for managing content
Page-based vs object-based; example and use-cases
* Things Mezzanine does well
Advantages of using Mezzanine over other CMS systems
* Things Mezzanine does not do well
Reasons not to use Mezzanine
recording release: yes license: CC BY-SA
29. Blind Analytics - getting insight from data without seeing the data
Brian Thorne
This talk will start with an overview of current methods of privacy preserving computation including homomorphic encryption, secret sharing, and differential privacy.
We will explore current uses of privacy preserving computation, in fields such as government, finance, telecommunications and IoT. We will look at the technological and social barriers to wider adoption then gaze into the crystal ball to see where the future might take us.
To conclude we will explore one technique (partially homomorphic encryption) with a motivating medical example. A high level overview of the open source library `python-paillier` will be given along with a few code samples showing how easy (some) privacy preserving analytics can be to implement.
recording release: yes license: CC BY-SA
30. Playing to lose: making sensible security decisions by assuming the worst
Tom Eastman
The unfortunate truth about networked applications is that an attacker only needs to know one thing you didn't know to get past your defences. You need to know everything, they don't.
The odds aren't in your favour. You're eventually going to get hacked.
That's the bad news. But if you stop thinking about a security compromise as "that thing you close your eyes and hope never happens", and instead start thinking about it as an inevitability, then you can start making better security decisions.
"If they compromise my web servers, how do I protect my application servers?"
"If they break my application server code, how can I prevent them from gaining a foothold on my infrastructure?"
"If they poison my web-site with cross-site scripting, how do I find out before my users get hurt?"
In short: "If I'm going to get hacked, how do I make it hurt less?"
This is a talk about defence in depth.
Building a secure system isn't about luck, it’s about planning.
recording release: yes license: CC BY-SA
Location
--------
C1
About the group
---------------
Kiwi PyCon is an annual conference aimed at promoting and educating people about the Python programming language. The New Zealand Python User Group is proud to present the ninth national Python conference in New Zealand.