The Development of OpenStack (Dougal Matthews)
OpenStack is an Open Source Python based infrastructure as a service (IaaS) platform. OpenStack manages virtual machines, distributed storage and the network between these services. Since OpenStack was originally released in 2010 it has grown at an astonishing rate. With over 1.3 million lines of code and around 1200 individual developers contributing in the last 6 months.
This talk will briefly introduce you to OpenStack itself and then focus on the scale of it’s development and the challenges this presents.
HTTP/2: Because The Web Was Too Easy (Cory Benfield)
The internet has spoken, HTTP is to get its first serious update in 15 years. In this talk we'll discuss what HTTP/2 is, why it's happening, and how it's going to affect you and everyone you love.
A Deep Dive into Requests (Cory Benfield)
Requests is one of the most popular third-party Python libraries ever written. Users love its clean and expressive API and its tendency to shorten their codebases.
That’s only part of the story, though. Behind Requests’ famous API lurks a number of exciting features that many users know nothing about. By using these features you can take your HTTP usage to the next level, speed up your code, and impress your friends (some of them, anyway).
In this short talk, we’ll do a quick pass through the Requests library itself pointing out its powerful features and tools. We’ll also take a look at some of the other libraries in the Requests ecosystem to see what they can bring to your code. We’ll talk about things like authentication, connection management, state persistence, SSL/TLS, transport adapters, and more!
This talk requires basic familiarity with the Requests library. No deep HTTP knowledge is required.
With a Pinch of Salt (Scott Walton)
Salt can be sprinkled over your food for flavouring. The same can be done with your servers, though I’d not recommend trying to eat them afterwards.
Salt is a very powerful server and configuration management system. It uses YAML and Jinja2 for configuration, so it should be familiar for most developers to get up and running.
In this talk, we will go through the basics of setting up Salt using a simple Django web app as an example. We can then build on this by introducing more of Salt’s features, such as selectors, grains, and pillars to construct and manage a complex system through testing, staging and production with relative ease.
Dealing with big black boxes (Fergus Doyle)
"Full-stack" includes so much more than just client and server these days, with systems building on top of multiple database engines, caching layers, search backends, third party web services and hosting solutions to name but a few.
What does this mean for infrastructure? In this talk we'll explore the impact maintaining so many independent cogs can have on a system as a whole.
We’ll look at third-party components vs. those developed and maintained in-house and their similarities and differences. How can we encapsulate and efficiently test components in such disparate systems? What can we do to minimise the overhead and risk of releasing new code to individual components nested deep within the machine?
Enterprise 101 (Martin P. Hellwig)
Red tape, arbitrary rules, office politics and clueless management, if these issues sum up your working day then you probably work in an enterprise like company. In this talk I'll take on the role of the devil's advocate in the expectation that some of my hypotheses about the underlying principles of those issues will have enough relevance to your situation that it can be applied to improve your working environment or at least understand why it can't be changed.
It's Not All About Success & Failure (Julian Berman)
There's more to software testing than just a green "All tests passed". Python is lucky to have a wealth of testing tools that can provide information on useful things like test timing, the long term behavior of a suite, or the comprehensiveness of a set of tests.
We'll investigate some of these tools and explore how they can help diagnose failures and provide insights into existing tests.
First steps with django CMS (Iacopo Spalletti)
An introduction to the philosophy of Django CMS and how to build flexible websites with it. You will learn how to handle content, writing templates and how to integrate your own Django applications with one of the best CMS for Django
Python for Zombies: 15.000 enrolled in the first Brazilian MOOC to teach programming (Fernando Masanori Ashikaga)
Python for Zombies is the first MOOC (Massive Open Online Course) to teach programming in portuguese. Our first edition had 15.000 "zombies". This course is different from traditional MOOCs (Edx, Coursera, etc). First is an initiative of the Brazilian Python community. Besides the difference of language, it is very "casual", as I have little time, I recorded most of the videos on my trips between meetings, conferences or at mealtimes. This MOOC is "brazilian", in a non traditional academic way. The size of the videos is far lower than the average traditional courses too. I will show you the most funny codes that I used in MOOC classes to teach programming: hacking basic modules and classes to obtain the "Answer to the Ultimate Question of Life, the Universe, and Everything". All material is Creative Commons Share Alike. The MOOC is based in my experience to teach programming in past six years at FATEC, a public university in Brazil, with decreasing rates of failure in the introduction to programming discipline. We have 100% class in labs, Coding Dojos to training and tests in exercises. Slides: http://bit.ly/python-for-zombies
Farewell & Welcome Home: Python in Two Genders (Naomi Ceder)
After half a lifetime "undercover as a man" I embraced my identity as a transgender woman and openly transitioned from male to female while staying involved in the Python community. This talk discusses that transition and how I found my new life in Python as a woman different from my former life as a man and the lessons about diversity I have learned.
This talk will include a brief discussion of what being transgender means, my experiences as I came to terms with it, and the losses and gains transition entailed. I will discuss my decision transition openly in Python community and how it was received.
While my transition has been exceptionally successful, I now inhabit a surprisingly different world. As a part of at least 3 groups that are minorities in the Python world I now have a very different view of a community I thought I knew. In addition to the many positives the Python community has offered me on my journey, I will discuss the experiences that have made me understand what it means to marginalized and that privilege is very much alive and well in the Python world.
Dr. Jython or: How I Learned to Stop Worrying and Love the JVM (Naomi Ceder)
Jython has many admirable attributes - running on a Java JVM, it doesn't have or need a GIL, in spite of not getting the love it deserves it works amazingly well, and it can even be used to embed a Python interpreter in Java code.
But even more important from an enterprise point of view is that Jython can use both pure Python and Java libraries side by side, and you still get to write your code in Python.
This talk is quick account of two similar occasions where Java libraries were the best choice for connecting to an ERP system, and Jython made it possible to write the applications in Python instead of Java.
There will be a quick rundown of the issues one encounters in using Jython for a use case like this, with some sample code showing both Java and Python using the same libraries.
Particular Issues covered will be:
- Care and feeding of the JVM
- Using the Jython shell to expore Java libraries
- Translating Java to Jython - tips and caveats
- Which Jython?
Building Great APIs in Python (Paul Hallett)
Applications are increasingly reliant on third party web APIs that provide complex services through a simple web interface. As such, it has never been more important understand how to build APIs with our favourite tools. T his talk covers the API development ecosystem available to Python, the best practices for building APIs, and a short demonstration of how easy it is to add an API to an existing Python app.
Self-Contained Deployment with Docker and Packer (Rach Belaid)
Deploying complex applications can be hard and rolling back is even harder. Ideally we would like to have the deployment self contained and be able to throw server resources to implement the deployment in an immutable way, but in practice this is difficult and takes lot of time to put in place. This is where a tool like Packer / Docker can help you to reach a self-contained deployment workflow in a much easier way. I will guide you through how to easily get started with immutable deployment and doing deployment (or rollback) of a self-contained application.
you’re doing it wrong: the lack of reproducibility in statistical science, and how to fix it (Mike McKerns)
A recent mathematical proof by Owhadi et al [1,2] details how many of today's common statistical methods are inherently unreliable. For example, Bayesian inference is only guaranteed to be correct when the selected prior is exact -- otherwise, the predictions are not guaranteed to be any more likely true than a random guess. Common tools in statistical science such as Bayesian inference, Monte Carlo, and Machine Learning impose strong implicit assumptions on a problem set in order to yield a solution. These methods do not provide a means for testing the assumptions the methods themselves require. For example, with Bayesian inference one must select a prior, where selecting a prior essentially turns the past into an explicit predictor of future events. Monte Carlo can never rigorously predict bounds on risk, and falls victim to the curse of dimensionality.
We have developed a comprehensive mathematical framework (OUQ) [3,4] capable of utilizing all available information to rigorously predict the impact of high-impact rare events, where our predictors are multiply-nested global optimizations over all possible valid scenarios. Such optimizations are high-dimensional, highly-constrained, non-convex, and generally impossible to solve with current optimization technology; however, by addressing optimization constraints as quantum operators on a probability distribution, our software (called 'mystic') [5,6] converts highly-nonlinear statistical calculations to those that are nearly embarrassingly parallel. By utilizing abstractions on programming models and global distributed caching of data and results, we can scale up from desktop calculations to petascale and larger with little burden on the programmer.
Within the context of this framework, assumptions inherent to common statistical science can be tested and validated, and models can be rigorously tested and improved. Results obtained are rigorous and optimal with respect to the information provided, and should enable great strides in reproducibility in statistical science. This framework has been used in calculations of materials failure under hypervelocity impact, elasto-plastic failure in structures under seismic ground acceleration, and the design of the next generation of large-scale heterogeneous compute clusters. Tools are included for rigorously constraining design space, constructing standard and statistical constraints, leveraging discrete and symbolic math, and quantifying uncertainties and risk.
This talk will lightly cover Owhadi's proof in pictorial form, however will primarily focus on the implementation of Owhadi's new rigorous statistical framework in the mystic software, and discuss the outlook and impact on scientific reproducibility in statistical science.
the failure of python object serialization: why HPC in python is broken, and how to fix it (Mike McKerns)
Parallel and asynchronous computing in python is crippled by pickle's poor object serialization. However, a more robust serialization package would drastically improve the situation. To leverage the cores found in modern processors we need to communicate functions between different processes -- and that means callables must be serialized without pickle barfing. Similarly, parallel and distributed computing with MPI, GPUs, sockets, and across other process boundaries all need serialized functions (or other callables). So why is pickling in python so broken? Python's ability to leverage these awesome communication technologies is limited by python's own inability to be a fully serializable language. In actuality, serialization in python is quite limited, and for really no good reason.
Many raise security concerns for full object serialization, however it can be argued that it is not pickle's responsibility to do proper authentication. In fact, one could apply rather insecure serialization of all objects the objects were all sent across RSA-encrypted ssh-tunnels, for example.
Dill is a serialization package that strives to serialize all of python. We have forked python's multiprocessing to use dill. Dill can also be leveraged by mpi4py, ipython, and other parallel or distributed python packages. Dill serves as the backbone for a distributed parallel computing framework that is being used to design the next generation of large-scale heterogeneous computing platforms, and has been leveraged in large-scale calculations of risk and uncertainty. Dill has been used to enable state persistence and recovery, global caching, and the coordination of distributed parallel calculations across a network of the world's largest computers.
Dockerize your Python apps! (James Pacileo)
Docker has emerged to be one of the latest and greatest innovations in the web development community. But what is Docker? And most importantly how can a Python Web Developer take advantage of it?
Data Matching and Big Data Deduping in Python (Nikit Saraf)
Till now, using real-world-data is difficult. Apart from encoding and missing value, multiple records which mean the same thing is one of the biggest headache. This talk will demonstrate two tools “Dedupe” and “Dedoop” to handle task of Data Matching and Deduplication in Python at the scale of millions and billions of records respectively.
One of the widely postulated theory is “Most of the time spent working with real world data is not spent on the analysis, but in preparing the data”, I believe any Data guy would agree. There are numerous problems, which crop up while cleansing any dataset, and the prominent and recurring problem is duplicates (It is duplicate, so it has to be recurring). The problem of matching data and information from multiple databases or sources is also a prominent problem encountered in large decision support applications in large commercial and government organizations. This problems has many many different names deduplication, record linkage, entity resolution, coreference, reference reconciliation, record alignment.
Accurate, Scalable and Fast entity resolution has huge practical implications in a wide variety of commercial, scientific and civic domains. Despite the long history of work on Data Matching, there is still a surprising diversity of approaches, and lack of guiding theory. Meanwhile, in the age of big data, the need for high quality entity resolution is growing, as we are inundated with more and more data, all of which needs to be integrated, aligned and matched, before further utility can be extracted.
This talk will present the key ideas implemented behind “Dedupe” an open source python library that quickly deduplicates and matches records at the scale of millions of records on the laptop. The aim is to show how “Dedupe” achieves speed by “Blocking” records, to save from O(n2) comparisons, achieves accuracy, by using better string comparators and clustering algorithms suited for this problem etc. The attendees would also gain understanding of the tradeoffs between the speed and accuracy.
But what about a billion records ? In such a scenario, it is imminent to parallelise the whole process, to achieve greater speed. So, enter MapReduce based Entity Resolution. Attendees would also walk away with the understanding of how the Deduplication procedure may be parallelised by distributing the task independently to the map and reduce stages. There would also be a demo of the same using “Dedoop” an open source Efficient Deduplication tool for Hadoop on Amazon EC2 Machines
The Twelve-Factor App (Kristian Glass)
Are you building web services? Do you have passwords and keys embedded in your code, readable by everyone who works on the project? Are you tied to your production environment, unable to move, needing painful hacks for local testing? Is every app a special snowflake to configure and run?
The Twelve-Factor App is a language and framework agnostic set of principles for building easily configurable, easily deployable, well-structured services. Follow these principles; they’re low-effort and low-maintenance, and will make your life easier, whether you’re deploying or writing code.
If you work on any kind of web service, you should attend this talk.
An HTTP request's journey through a platform-as-a-service (Giles Thomas)
PythonAnywhere hosts tens of thousands of Python web applications, with traffic ranging from a couple of hits a week to dozens of hits a second. Hosting this many sites reliably at a reasonable cost requires a well-designed infrastructure, but it uses the same standard components as many other Python-based websites. We've built our stack on GNU/Linux, nginx, !uWSGI, Redis, and Lua -- all managed with Python. In this talk we'll give a high-level overview of how it all works, by tracing how a request goes from the browser to the Python application and its response goes back again. As well as showing how a fairly large deployment works, we'll give tips on scaling and share a few insights that may help people running smaller sites discover how they can speed things up.
Exploring unit-testing with unittest, nose and pytest (Tom Viner)
We'll start by briefly introducing our three test frameworks:
unittest (sometimes called PyUnit) and it's !xUnit origins
- nose: "extends unittest to make testing easier"
- pytest: more pythonic tests?
We'll look at several features of unit-testing and how they're covered by our frameworks. Covering:
- running your tests from the command line
- a minimal test: with class or function?
- setting up the environment for a test, and clearing up afterwards
- happy path: asserting the expected truth
- provoking failure: ensuring exceptions raised
In the remaining time we'll move on to some more advanced techniques:
- parameterised test generators
- skipping and xfails
- next level: marking your params
Try A Little Randomness (Larry Hastings)
This talk is all about random numbers--what are they? What different kinds are there? What are they useful for? And why are computers really bad at them? Come learn all about random numbers, both the good and the bad.
Use of Openstack CI for your own projects (Yolanda Robla Mota)
Session will cover the basics about the CI process we follow at Openstack. It will dig on how it can be reused to setup a great CI system for own projects I will show the basics of deployment and configuration, highlight the efforts we are doing to make the CI system totally independent from Openstack requirements, and explain how to contribute to that project to people interested on it.
Python Refactoring with Rope and Traad (Austin Bingham)
Python is a modern, dynamic language which is growing in popularity, but tool support for it is sometime lacking or only available in specific environments. For refactoring and other common IDE functions, however, the powerful open-source rope library provides a set of tools which are designed to be integrated into almost any programming environment. Rope supports most common refactorings, such as renaming and method extraction, but also more Python-specific refactorings, such as import organization. Rope’s underlying code analysis engine also allows it to do things like locating method definitions and generating auto-completion suggestions.
While rope is designed to be used from many environments, it’s not always easy or ideal to integrate rope directly into other programs. Traad (Norwegian for “thread”) is another open-source project that addresses this problem by wrapping rope into a simple client-server model so that client programs (IDEs, editors, etc.) can perform refactorings without needing to embed rope directly. This simplifies dependencies, makes clients more robust in the face of errors, eases traad client development, and even allows clients to do things like switch between Python 2 and 3 refactoring in the same session.
In this session we’ll look at how rope operates, and we’ll see how traad wraps it to provide an easier integration interface. The audience will get enough information to start using rope themselves, either directly or via traad, and they’ll see how to use traad for integrating rope into their own environments. More generally, we’ll look at why client-server refactoring tools might be preferable to the more standard approach of direct embedding.
Advanced py.test fixtures (Floris Bruynooghe)
One unique and powerful feature of py.test is the dependency injection of test fixtures using function arguments. This talk aims to walk through py.test's fixture mechanism gradually introducing more complex uses and features. This should lead to an understanding of the power of the fixture system and how to build complex but easily-managed test suites using them.
Ganga: an interface to the LHC computing grid (Matt Williams)
Ganga is a tool, designed and used by the large particle physics experiments at CERN. Written in pure Python, it delivers a clean, usable interface to allow thousands of physicists to interact with the huge computing resources available to them.
PyPy and its ecosystem (Ronan Lamy)
PyPy is a fast, compliant alternative implementation of the Python language (2.7.6 and 3.2.5). I will give an overview of the current status of and the on-going development efforts on all the pieces that combine to make it a compelling Python platform. In particular, I will mention the RPython toolchain, CFFI, the JIT, garbage collection, the numpy port, Python 3 support, software transactional memory.
The IPython Notebook is for everyone (Gautier Hayoun)
!IPython Notebook is a vastly underrated tool in the Python eco-system.
In this talk I will show what is !IPython Notebook, examples of what you can do with it and hopefully inspire you to use it for your own problems.
This should be interesting even if you build web applications or manage servers.
How to Glue Your Radio (Leonardo Fiorini)
"How to Glue Your Radio", or, in other words: how to combine a bunch of incompatible pieces of software, force them to collaborate in order to automate the most important (and boring too) tasks for a radio station. To all of them who don't want to reinvent the wheel, here for you a refined selection of the most dramatic problems and the best solutions created by Radiocicletta's Hacker Team, and published on github (http://github.com/radiocicletta).
Useful, tested, and open software for everyone.
Studying astronomy at the University of Warwick using Python (Simon Walker)
We at the astronomy group at the University of Warwick use Python for a wide range of tasks. From efficient image reduction through numpy array manipulation, high performance analysis by wrapping C++ code, or use of the multiprocessing module, Python is utilised for many applications.
The astronomy group studies other worlds, searching for extrasolar planets with new projects such as NGTS, and utilising results from the Kepler project. Also studied are the most distant objects in the universe, where massive explosions are visible from colossal distances. Cold dying stars known as white dwarfs are modelled as systems orbiting and stealing mass from their companion stars.
Python enables our understanding at the Warwick astronomy group. In this talk I discuss topics covering the whole scientific process from manipulating raw data and correcting for systematic errors, through analysis incorporating modelling and understanding the results, to visualising the final products ready for publication.
The High Performance Python Landscape (Ian Ozsvald)
A Python programmer has many options to profile and optimize CPU-bound and data-bound systems, common solutions include Cython, numpy and PyPy. Increasingly we have single-core solutions that should take advantage of many cores and clusters. This talk reviews the current state of the art, looking at the compromises and outcomes of the current approaches and reviews upcoming solutions like Numba, Pythran and PyPy’s numpy and STM. Thoughts will be shared on how current hindrances might be improved.
Learning Python in Africa Universities (Olaniyan Adewale)
The session will of help to open source communities in the world by spreading the knowledge of open source technologies to Africa. It's been so pathetic that Africa has not been contributing to the open source technologies since it's innovation. However, this session should be an eye opener to developer in the world that it is high time to take more effort in contributing to Africa Technology through Open Source by adding it to Higher Institution Curriculum.
Let your data go/grow/flow with Py2Neo (Colin Moore-Hill)
This is a high level introduction to graph Databases and in particular Neo4J and how to use then utilising the py2neo wrapper.
This will cover the basis of the data structure and modelling as well as an introduction to the Cypher query language.
Trouble at t'LeedsDataMill: Oompah.py ~ Big Data meets Big Brass (Nicholas Tollervey & Simon Davy)
We will describe and (maybe) perform via the medium of Brass Band footfall data collected from the city of Leeds.
It's likely to be a loud, fun, interesting and musical exposition of big data manipulated with Python.
It may involve Tubas.
Stormy Webber - Tornado for everyone (Wes Mason)
An introductory talk to building fast non-blocking async web services with Tornado, especially relevant to Django, Flask, bottle, web.py, Pyramid, Zope, Gevent, Twisted and every other web (or not) dev interested in learning what makes Tornado special for such tasks.
Bonus: advanced tips and tricks for migrating from current systems and working with technologies such as WebSockets and Server Sent Events in Tornado.
Is that jumper made of cats? Matching fashion products with image similarity. (Eddie Bell)
Given two non-identical images, how can we decide when those two images represent the same fashion product? The images can have different backgrounds, models, rotation, lighting and scale. In this talk I will show how we do this at Lyst in python using k-means bag-of-words on BRISK image descriptors.
Where am I? Geospatial processing with Python (Ian Taylor)
Turns out not only is the world not flat, it's not round either! And, everybody measures it differently in their hometown. So converting geo data is hard (= lots of math!) and you can't do it just with sql, sed, awk. You can do it with Perl ... but who wants to do that!!??
Enter Python. Really fast iterative development copes with data 'anomalies' (bugs to you and me). Extensive library support for SHP, WKT, CSV, databases makes data I/O effortless. Well, um, yeah ... easier. ;o)
The problem initially looks like text or stream processing: the function machine. You don't need classes for that, right? Hmmm, maybe ...
Geospatial processing requires more libraries (shapely in this case). Then more anomalies, math problems, but - hurrah - it works!
Mapping (of course) is about a journey, so along the way we'll meet friends and enemies like globals, classes, PEP8, IDEs and a cast of colourful characters!
How to become an !OpenStack hacker (Milap Bhojak)
The goal of OpenStack is to produce a ubiquitous open source cloud computing platform that will meet the needs of public and private cloud providers, regardless of size, by being simple to implement and massively scalable.
This talk will look at some projects that are running OpenStack, and will look at how to contribute to the development of OpenStack.
Pioneering the Future of Computing Education (Carrie Anne Philbin & Ben Nuttall)
Carrie Anne Philbin and Ben Nuttall of the Raspberry Pi Foundation talk about the foundations education mission, how raspberry pi and python is being used in the classroom, and most importantly how you can get involved.
Functional Programming and Python (Pete Graham)
What is functional programming, and when would you want to use it?
Can you use Python to write programs in a functional style? Is this a good idea? What are the limitations, and when should you use an alternative functional language such as Haskell (Scala, Closure, Erlang, Lisp, etc).
When performance matters... (Marc-Andre Lemburg)
Python applications sometimes need all the performance they can get. Think of e.g. web, REST or RPC servers. There are several ways to address this: scale up by using more processes, use Cython, use PyPy, rewrite parts in C, etc.
However, there are also quite a few things that can be done directly in Python. This talk goes through a number of examples and show cases how sticking to a few idioms can easily enhance the performance of your existing application without having to revert to more complex optimization strategies.
Python Web Installers (Marc-Andre Lemburg)
Installing Python packages is usually done with one of the available package installation systems, e.g. pip, easy_install, zc.buildout, manual "python setup.py install".
These systems work fine as long as you have Python-only packages. For packages that contain binaries, such as Python C extensions or other platform dependent code, the situation is a lot less bright.
In the talk I will present a new web installer system that we're currently developing to overcome these limitations. The system uses the dynamic Python installation interface that all installers support ("python setup.py install") with a web installer which automatically selects, downloads, verifies and installs the binary package for your platform.
Dependency Injection in Nameko (Matt Bennett)
Nameko is a python framework for building service-oriented software, developed by onefinestay. This talk will explain how nameko uses Dependency Injection, why it's an important paradigm and how it simplifies writing services and testing them.
Nameko is on GitHub at https://github.com/onefinestay/nameko
The Minecraft Challenge (Katie Bell)
There's already a great Python scripting interface for Minecraft, allowing you limitless creativity with the ability to read and place blocks anywhere. Unfortunately with limitless power the challenge of Minecraft disappears, because building a castle is somehow more satisfying when you have to mine and craft every block. If you’ve played Minecraft you’ve no doubt found yourself building or mining mindlessly in a pattern and wished you could simply script away the boring bits, but still keep the fun and challenge of the game.
In this presentation I'll be demonstrating a Python interface for writing Minecraft AIs, giving you the programming equivalent of Survivor mode. Your helper robots have some advantages over humans and can mine and build things for you faster, but ultimately this doesn't feel like cheating because it can’t do anything you can’t do. This also works well in multiplayer on an open server where players and bots can interact but no single player can destroy the world with a small software bug.
Writing an AI for the Minecraft world poses an interesting challenge for both young and experienced programmers, it’s a pure example of how we can use programming to avoid boring and repetitive tasks in the real world. It provides new programmers with immediate goals and for students exploring more advanced computer science concepts it leads well into real world robot control and game AI algorithms.
In this talk, I'll go through the Minecraft server and client implementation details, the challenges of multiplayer programming and the structures built into the interface to make coding AIs easier such as built-in state machines and the ability for the in-game player to give commands.
As a bonus, we’ll see how it plays out in the real world, what happens when we give the interface to a group of young programmers on a shared server, and how we can set up competitions and more specific AI-coding challenges.
The knights who say Neo - storing classes in the graph (David Szotten)
Ever wondered what happens if you store your Python classes directly in your database? (And no, we’re not talking about pickling)
When faced with the problem of modelling a large, complex type hierarchy of "stuff one might find in a seven bedroom home", we went down the somewhat unusual route of storing not only the objects themselves, but also their types in a graph database.
In this talk we will take a look under the hood of Kaiso, the open source framework we built to do this, and how we use some metaclass magic to to make it all happen.
Unlike conventional ORMs, we needed the schemas to be as dynamic as the records, and so decided to keep them side by side in our neo4j db. Using the Python type system as our data model means we get features like hierarchy consistency checks and other type calculations for free.
While this might not be the solution to a particularly common problem, come along to see how we’ve used some of the more dynamic aspects of the Python language for fun and profit!
Rapid prototyping to industrial strength : Python in Government (Michal Olszewski, Jim Gumbley, and Max Edwards)
One team goes on a journey to prove that iterative lean approach can deliver results and change how organizations work. By deliberately choosing Python and a micro-framework approach our team is building an online public service which will help UK citizens to claim their redundancy payments. This is the story of how the team approached problems and devised solutions while staying true to Python philosophy.
Practical introduction to machine learning via Kaggle problems (Ezzeri Esa)
Spending months on the nuances of machine learning models is a luxury most of us don’t have. This hands-on, practical !iPython tutorial aims to provide a highly-directed introduction to machine learning through solving Kaggle problems. We’ll start with data manipulation using pandas - loading data, cleaning data and making simple plots. We then use scikit-learn to make predictions. By the end of the session, we would have solved a supervised learning problem from start to finish, as well as see how well we did on the leaderboard. Time-permitting, we will review a number of ways to improve our results - through feature engineering, cross-validation and model parameter selection.
Integrating Python and C++ with Boost.Python (Austin Bingham)
Python and C++ are both popular languages that each bring a lot to the table. The languages also complement one another well: Python is high-level, dynamic, and easy to use while C++ is at-the-metal, static, and (in)famously tricky. There are times when there are real advantages to combining these disparate natures, and Python’s C API provides a strong interface for doing just that. Boost.Python is a C++ library that builds upon and improves Python’s C API to give users a simpler, more intuitive, and safer means to integrate Python and C++.
In this tutorial we’ll look at how to use Boost.Python to effectively bridge the Python/C++ boundary. We’ll start by briefly looking at the fundamentals of the Python C API since that defines the “ground rules”; this includes things like reference counting, the basic object model, and so forth. We’ll then quickly look at the Boost.Python API and show how it provides the same functionality as the underlying C API, but does so in a way that doesn’t obscure the real semantics of the Python language.
After this introduction, the rest of the tutorial will involve writing code to explore various elements of Boost.Python. We’ll focus on techniques for extending Python with C++, that is, writing Python modules in C++. Boost.Python can be used for embedding (i.e. invoking Python code from C++), but that involves a different set of techniques and more time.
The syllabus for the two-hour tutorial will be like this:
- Introduction: C-API and Boost.Python basics
- Hello World: Exposing a basic function
- Exposing functions
- Exposing classes
- Derived object types
- Type conversion
This is a fairly ambitious set of topics, and it’s likely that we won’t be able to cover them all in a two-hour session. The topics are roughly in most-often-used to least-often-used order, however, so students will be sure to be exposed to the most important and relevant elements of the course.
Likewise, the two-hour format of the course means that we won’t be able to go into great depth on many topics. The main goal of the course, then, is to give students enough orientation and hands-on experience with Boost.Python that they can continue to learn on their own. Inter-language integration - especially between languages as dissimilar as C++ and Python - can be quite complex, but this tutorial will give students the grounding they need to successfully apply Boost.Python to their problems.
Python in game development (Denis Kovalev)
I'll talk about how Python is used in game development, review popular libraries, game and physics engines, show their pros and cons. We'll cover processing user input, animations, adding physics to the game, menus creation.
Mostly we'll focus on Cocos2d, PyGame and Pymunk libraries. The talk also covers handy tools for game developers: 2D and 3D editors for graphics, models and sprites creation, level editors.
In the second part of the talk I'll show how to create a simple game from scratch using tools that we'd have learnt.
Event Sourcing in Python (Robert Smallshire)
Most Python applications today follow a classic architecture where a data or domain model is implemented in terms of mutable data structures, be they relational database tables accessed via an object-relational mapper, or more free-form data stored in a graph or document store. Mutability implies the obliteration of historical state, and attempts to overcome this shortcoming often lead to overly complex models and applications.
Event sourced architectures take an alternative approach of storing all changes to a model in an append-only store as they occur. The stored history is immutable – bringing numerous scalability benefits – and contains sufficient information to reconstitute the model at any point in its history.
In this tutorial we implement a simple persistent domain model in Python backed by event-sourced persistence without any need frameworks, ORMs or even a database!
Python and Spatial Data (Valentin Hancu)
GIS has many applications in various fields today. It's used in food production, housing, health, wildlife conservation, water systems, community analysis, social inequalities and spatial justice studies, etc. Working with spatial data has become widespread today and Python has become an important language for this
The scope of this tutorial is to present to those interested the basics of spatial analysis, we will use open-source libraries and tools.
This tutorial will have three parts: a fist part in which will be presented main concepts in GIS, it will continue with a live demo session , almost 90 minutes of exercises and practical examples, and it will end with a Q&A session.
Nameko Tutorial (Matt Bennett)
A code-along tutorial demonstrating some different ways to use nameko. We will walk through at least one of the following:
- A distributed chat server, where participants can add their own services to enhance messages
- A work distribution cluster for solving an embarrassingly parallel problem
- A simple SOA to perform sentiment analysis on #pyconuk tweets
Nameko is on GitHub at https://github.com/onefinestay/nameko