by John Pinner
by Jacob Hallén
by John Pinner
by Antonio Cuni
PyPy is probably the fastest Python implementation around, thanks to its automatically generated JIT compiler. This talk explains how the JIT works internally: in particular, it shows all the intermediate steps which lead to the compilation of the Python source into fast machine code, and how to use the right tools to inspect the output of the JIT compiler.
So you have selected the best possible programming language; you learned about object oriented design, functional paradigmas, test driven development and the Structure and interpretation of computer programs. What else can you do? Harald did research and experimented outside computer sciences. What methods and substances are available to tune your brain for programming? This talk will describe personal experiences with various motivational, self discipline, learning and information management techniques; substances and exercises to tune your brains operating system. There will be expeditions into results from brain research. A critical judgement, pointing out snake oil and stuff that worked.
by John Pinner
The Larch Environment is a new experimental programming environment for Jython. If you have seen Bret Victor’s talk ‘Invent on Principle’ and Chris Granger’s Light Table, you no doubt appreciate the need for investigating new approaches for programming. The Larch Environment is a research project aimed at developing a new Python based visual programming environment in which Python programs take the form of visual, interactive documents. In Larch, interactive, visual representations of Python (and Java) objects are the norm. A new form of visual programming allows code and interactive graphics to be freely combined.
HTML5 Clientside apps, phone apps, tablet apps are all the fashion. Zeth explains how you can develop these using your existing Python knowledge as much as possible through the use of Python powered RESTful servers, server-side validation of data, NoSQL databases and JSON powered mobile apps.
by Benjamin Young
"In the face of ambiguity, refuse the temptation to guess." NoSQL's ambiguity is well known. What is it? How is it different? As it turns out, NoSQL document storage databases such as Couchbase achieve PEP 20 "compliance." We'll hit some of the most applicable Zen of Python aspects and see how Couchbase Server achieves them, and how to use the Couchbase Server Python SDK to add some pythonic nosql goodness to your next application.
by Wes Mason
As internal HTTP REST services, popularised by Amazon, have been gaining a lot of attention - newly emerging HTTP/1.1 extensions like Server Sent Messages and WebSockets are the perfect accompaniment to asynchronous tech stacks like Tornado, Twisted, Gevent and Node.js, not just for powering 10 minute chat demos.
by Ross Lawley
As more people adopt relational models for applications, there is a greater need for ODMs to manage flow between language libraries. Using mongoengine as an example we'll look into the technical aspects of building a fully featured Object Data Mapper for mongoDB. We'll cover why we want an Object Data Mapper for a schemaless database, followed by a technical deep dive into mongoengine internals.
* use of Meta classes to add functionality to the document mappings
* creating a custom query language
* handling data conversion between mongoDB and mongoengine
* being able to deal with truly dynamic data
* transparently handling changed data.
by Chris Dent
TiddlyWeb was initially created as an open source, reference implementation of an HTTP API for server-side storage of TiddlyWiki tiddlers. Since then it has evolved to being a flexible architecture for persisting tiddlers as general web resources. TiddlyWeb was developed in Python (2) without a framework to insure it was maximally transparent. Because of this, its architecture provides insights into techniques, advantages and pitfalls that come with developing a straight WSGI application. The same layered and modular approach used for web handling can be very useful elsewhere in the stack, especially with regard to flexible storage mechanism, such as integration with sqlalchemy and Redis. TiddlySpace, a derivative of TiddlyWeb, takes advantage of this flexibility to create a highly scalable web service that works alongside nodejs, memcached and beanstalkd. The talk will describe the architecture, the advantages that come from using it, and the tools used to manage it.
The following links point to some other papers or talks that provide some background on TiddlyWeb and TiddlySpace. This proposed talk could easily be the "How" to go along with the "Why" below.
* "TiddlyWeb: HTTP for Tiddlers": http://peermore.com/http_tiddler... * http://totw.tiddlyspace.com/Why, which are the notes used to develop * "Tiddlers on the Web": http://burningchrome.com/~cdent/... * http://tiddlyweb.com/ * http://tiddlyspace.com/ * https://github.com/cdent/tsapp
My github: https://github.com/cdent My CV: http://peermore.com/chris_dent_r...
The Python logging module is a useful tool for getting all kinds of information out of your program; everything from error notifications through to debug information. The standard facilities are useful out of the box, but, sometimes, you need a bit more. Not surprisingly, it turns out that the logging module is designed to be extended. This presentation shows some of the things you can do; things like gathering statistics on message type, directing emails to different recipients depending on severity, dynamic updating of attributes, and logging to a database.
The talk covers:
* an overview of why I thought I needed the extra features,
* a look at the logger structures that need to be changed,
* and some actual code that does the job.
by Tom Wardill
Monitoring solutions exist for servers and services. Now, can we turn those solutions towards monitoring other things. Can you graph your git commits against your heart rate, and know how many cups of tea it took to make that code, without manual intervention?
A brief talk about what we're planning to release for PyConUK 2013.
Pretenders are fake servers for testing purposes. They are used to mock external servers your code interacts with (such as HTTP APIs or SMTP servers).
This is an open source project, source code is in http://github.com/txels/pretenders
28th–30th September 2012