Ecosystem threats to Python (Van Lindberg)
Python is a spectacular success - far more than anyone, even Guido, would have anticipated 20 years ago. Python is preinstalled on almost every operating system, is becoming the lingua franca for many numeric, statistical, and big data problems, and is the default teaching language in many colleges and universities.
Lessons from Strangers (Rachel Sanders)
Why are some workplaces vibrant and innovative, and others fetid pits of despair? Why are some products loved and others DOA? I dove into the strange world of business and psychology and emerged a better engineer.
Discovering developer habits with OpenStack code review data (Dougal Matthews)
What time of day are you most productive? How long does it take for a review to get merged after it has been submitted? Is the number of people reviewing each patch increasing or decreasing over time? Do some reviewers or companies favour specific developers?
Those are some of the questions this talk aims to answer. Given 120k code reviews in the Python based OpenStack project, what can we learn about developer behaviour? What lessons can it teach us to help us review code better and be more efficient?
Using IPython notebook and Pandas we will explore this data, asking questions of it and seeing what correlations we can find. Along the way we will look at Pandas and IPython notebook and introduce a number of its features and functionality.
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.
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 & 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.
Selenium Simple Test - An experience report. (Peter Russell)
Selenium Simple Test (SST, http://testutils.org/sst/ ) is an open source Python framework for writing automated tests for web applications. SST tests use Selenium Webdriver to drive real web browsers around the system under test.
The Test People recently used SST for the first time in a large project for a client. In this talk I'll cover:
* How SST compares with other approaches to writing automated functional tests for webapps. * Why we thought SST was an appropriate choice for this project * What changes we needed to make to the framework to support our needs * What changes I'd like to see in the future * Whether I'd recommend SST for future projects.
Simulating quantum systems in Python (Katie Barr)
Quantum theory is famously difficult and paradoxical, but exploring quantum systems numerically in high level languages such as Python is surprisingly easy. In this talk I will describe, step by step, how to simulate a particular system, the discrete time quantum walk. This is the quantum analogue of a classical random walk, and has some interesting properties which I will briefly describe. The simulation can be performed with just 15 lines of Python code, using no external modules. I will then indicate how simple variations on this simulation are used to perform current research into the discrete time quantum walk, as the example I give is a variation of Grover's algorithm, which is asymptotically the fastest possible quantum search algorithm. By the end of the talk listeners should be able to go away and perform their own simulations of this system. I will also indicate further motivations for using Python to investigate quantum mechanical systems, in particular using numpy support for linear algebra, which is one of the types of mathematics used by quantum theorists. There will be no mention of the trickier aspects of quantum systems, but, for those interested, I will provide materials describing how to measure entanglement and explore the effects of measurement in the quantum walk I have presented. I do not expect listeners to have any background in mathematics and physics, and will keep technical discussion which would require such background to a minimum.
Web based application automation at the protocol level (Katie Barr)
Python has support for both capturing data concerning networking activity, using browsermod proxy, and generating it using the requests module. The requests module has sophisticated support for generating HTTP requests and analysing their responses. This enables us to get a good understanding of what browsers do for us behind the scenes. With this understanding, we can automate browsing sessions, which enables testing at the protocol level. In cases where testing via the UI is difficult, a protocol based approach is more suitable. In this talk I will describe a command line tool developed in Python, which, for a simple HTTP archive (a snapshot of the session), generates a Python script which will replicate the requests made in the session. The tool uses the jinja2 templating language for the code generation, and creates an object which inherits from the requests 'Session' object to perform the requests, giving us the full power of the requests module.
Automated Report Generation with IPython Notebook (Adam Hodgen)
IPython Notebook is a web based interface to execute python code, along with options to include LaTeX equations, charts and diagrams, and many other forms of media.
In this talk I will discuss how we have included IPython notebooks in our workflow during large automated test executions. We are often required to do analysis of complex datasets and IPython notebooks allow us to rapidly gather information and clarity on how our tests performed. The notebooks also simplify further analysis for repeated executions, which significantly reduces turnaround time. I will also show how, along with IPython’s nbconvert, it is possible to turn an IPython notebook into an attractive, branded, report, which can be rapidly delivered with minimal effort.
Data traceability through data annotation (Fredrik Haard)
When writing data aggregation tools - for example for "business intelligence" - no amount of test cases can guarantee that the data you display to the end user is the data they need - or believe they are seeing. By it’s very definition, data aggregation tools removes information about the data, and it may very well take a domain expert - who may or may not understand the application itself - to manually verify that the data presented is indeed the data that is needed.
Testing and verifying the operation of such an application when testers and/or developers don’t have an intimate knowledge of the domain presents a challenge. In this talk I’ll present a way of providing traceability for your data, so that anywhere you show a data point, you can also explain exactly how it was computed.
I will show a full-stack example implementation modelled after a real customer case of how data can be annotated by (ab)using the Python object model to allow information on data source and operations to follow the individual data points all the way up through the stack to client-side rendering, as well as discuss some drawbacks to the methods used.
Teaching children to program Python with the Pyland game (Alex Bradbury)
This summer, a team of interns at the University of Cambridge Computer Lab have been working on a project to teach children to program in Python through a programming game. The primary target platform is the Raspberry Pi, though multi-platform ports are planned for the future. It is, of course, open source. The game consists of a number of challenges and puzzles which invite the user to apply programming techniques in order to progress. I will discuss the motivation for the game, give a demo, give some insight into its implementation, our plans for the future, and how you can get involved.
Post Mortem Debugging and Web Development (Alessandro Molina)
Developers often tend to ignore that users can be more creative than them. Use their debugging skills for your own benefit: post-mortem debugging is one of the most important features your web framework can provide.
The talk will cover some of the most common practices and available tools for debugging on development and production environments and immediately improve quality of your web applications through feedbacks from your running software and the interaction with your users.
DEPOT, story of a file.write() gone wrong (Alessandro Molina)
DEPOT ( http://depot.readthedocs.org/en/latest/ ) is a file storage framework born from the experience on a project that saved a lot of files on disk, until the day it went online and the customer system engineering team diceded to switch to Heroku, which doesn't support storing files on disk.
The talk will cover the facets of a feature "saving files" which has always been considered straightforward but that can become complex in the era of cloud deployment and when infrastructure migration happens.
After exposing the major drawbacks and issues that big projects might face on short and long terms with file storage the talk will introduce DEPOT and how it tried to solve most of the issues while providing a super-easy-to-use interface for developers. We will see how to use DEPOT to provide attachments on SQLAlchemy or MongoDB and how to handle problems like migration to a different storage backend and long term evolution.
Like SQLAlchemy makes possible to switch your storage on the fly without touching code, DEPOT aims at making so possible for files and even use multiple different storages together.
Using python to improve government (Michael Brunton-Spall)
The Government Digital Service is helping to transform government, helping to provide user led, high quality digital services to make citizens lives easier. One of the projects is based in Birmingham, dealing with giving citizens redundancy pay if their employer goes insolvent. We took a team of .NET engineers with no experience of agile development, and built a project in Python, iteratively, following government security principles. In this session, you'll learn why we picked python, how we convinced management, and how we convinced the developers
How does a spreadsheet work? A tour of the codebase of Dirigible, the Pythonic spreadsheet (Harry Percival)
Have you ever wondered how a spreadsheet works? It's actually surprisingly simple.
Join me for a tour around the codebase of Dirigible, the Pythonic spreadsheet (recently rescued from its abandonware status and made open source).
Find out how cell formulae are parsed and evaluated to become cell values, how the dependency graph of the spreadsheet is built, and how custom python code can be merged into spreadsheet calculations without everything exploding violently.
Repeatable, automated cloud deployments (Michael Foord & Simon Davy)
Do you deploy your Python services to Amazon EC2, or to Openstack, or even to HP cloud, joyent or Azure? Do you want to - without being tied into any one of them?
What about local deployments with lxc or kvm containers. How about managing your bare metal servers through Metal As A Service and deploying to OpenStack on top? ISP grade technology for your data centre!
How about managing your service deployment and infrastructure with Python code? (Devops distilled.)
If any of this sounds interesting then Juju maybe for you! Treat your servers as cattle not as pets, for service oriented repeatable deployments on your choice of back-end. Orchestrate and relate your services with charms written in Python.
In this talk we'll demo service deployment for a Django application and related infrastructure.
Tests without boilerplate (Jonathan Fine)
This talk is about a new way of writing tests. We arrange matters so that the expression statement
add(2, 2) == 4
reports a test failure if add(2, 2) does not return 4. Similarly
add(2, '2') ** TypeError
reports a test failure if add(2, '2') does not raise a TypeError exception. These new semantics (which provide no-boilerplate testing) do not apply when comparison expressions are used in conditional statements etc.
I will demonstrate Python software that implements this, and will discuss with you the use, benefits and development of this new approach to writing tests.
Python Core Development on Windows: Pleasures & Pitfalls (Tim Golden)
Python is a cross-platform language. ANd Windows has long been a first-class target for Python: it's one of the three classes of OS which the core development team undertakes to support and to test for on its buildbot fleet.
But Python itself still thinks, by and large, in Posix. And Windows-based contributors are a tiny minority. Sometimes that mindset skew shows in some of the choices which have to be made.
This talk will cover the essentials of the toolset needed to even build a modern Python on a modern Windows. It will look at some of the challenges you face when deciding how to approach some Windows-specific issues. And it will reflect on the help and support which is out there; somewhere.
Collaborative, streaming, 3D, and interactive matplotlib, ggplot2, and MATLAB plots in an IPython Notebook with Plotly (Carole Griffiths & Chris Parmer)
Plotly's Python API lets you make and share beautiful, web-based plots. This talk will be a walk-through of Plotly's library. We will craft and embed interactive graphs within an IPython Notebook, use Plotly's web-app to edit and share graphs, and use Plotly's matplotlib wrapper to create web-based graphs and data files from matplotlib scripts.
Plotly is the easiest way to graph and share your data online. Plotly allows you to make beautiful, interactive online graphs from Python, R, or MATLAB code or with its web-based spreadsheet tool. Public sharing is free, users own their data, and users control whether data and graphs are public or private.
Micro Python - my experiences running a successful Kickstarter campaign (Damien George)
The Micro Python Kickstarter campaign was successfully funded in December 2013 and had close to 2000 backers. In this talk I will discuss the ins and outs of the Kickstarter campaign itself, highlighting the good and bad bits of having an overwhelmingly successful crowdfunding project.
Micro Python - shrinking Python down to run on a microcontroller (Damien George)
Micro Python is a rewrite of the Python language that uses minimal RAM and which is optimised to run on a microcontroller (basically a very small computer). I will outline the architecture of Micro Python, explain how it minimises RAM usage, and discuss its benefits and use in the embedded electronics world.