python - 3.11.2009 - 1.3.2010

Semanchuk.com - Python IPC Modules - inter-process communication with Python.

Johnny Cache v0.1 documentation - definitely try this out with a project at the company, as the model is quite powerful and I could elegantly solve some of the problems for which I currently have special solutions. It's also quite similar to my first approach to this problem (although I have now solved the biggest performance problems through redundant data storage and automatic updates to objects, also quite elegantly).

LinuxTuples - a Tuple-Space Server for Linux, written in C but with a Python API. I should take a closer look, could be interesting for distributed apps. Although I would prefer a Python-local implementation based on standard process communication tools to work better with multiprocessing in Python. For simple tools or web apps, it would be easier to fork some things directly from there and then communicate via TupleSpaces. But to start an extra server for that, it's not quite right either.

PiCloud | Cloud Computing. Simplified. - very interesting service: trivial distribution of Python code (with access to C/C++ libraries for number crunching and other things, e.g. also image processing, even your own C/C++ libraries are possible) on a provider-managed EC2 grid. The programmer only writes his Python code, tests locally, if everything works well with small sets, upload base data, import, function call and wait until the results are there - payment is made according to usage time. Definitely keep an eye on it, in case you need to process larger amounts of data - this can indeed be cheaper than providing the necessary resources yourself.

rfc1437 / django-standalone / overview — bitbucket.org - As I often refer to Bitbucket, GitHub, or Google Code, here's a link to my own small package on Bitbucket: django-standalone. It was created because I often need an ORM for small scripts and tools, but I want to keep the hassle to a minimum - not set up an entire Django project, but simply define a few models in my script and initialize the DB via parameters and then use it. Preferably with sqlite3. This library makes it wonderfully easy, and I can finally cross one of my long-standing projects - "write a simple ORM for simple scripts myself" - off my to-do list.

iphone-backup-decoder - Project Hosting on Google Code - the same again as a command-line script in Python. Possibly even more interesting for me than the GUI tool.

dajaxproject.com - easy to use ajax library for django - maybe I should take a look at that, the current project might use quite a bit of Ajax and if you can reduce the amount of JavaScript that would be quite desirable.

IronPython 2.0 and Jython 2.5 performance compared to Python 2.5 - word of warning: both Jython and IronPython are significantly (and I mean significantly significantly) slower than CPython. The overhead for Jython with very large data structures is eventually better than with CPython, but for normal use it doesn't look so great.

IronPython hammers CPython when not mutating class attributes - more information about the performance issue. Here related to IronPython - apparently class variables can be problematic in some cases, as the classes themselves change through them and thus JIT compiler information must be discarded (due to the rather static structure of the VM, both in the JVM and in the CLI, probably a very similar problem), which means the JIT compiler then has to rework everything and thus not only are performance advantages lost, but they can potentially even be counterproductive.

bpython interpreter - definitely try this out at the company, at home this alternative Python shell made a really good impression. In some points better than ipython and that is already very good (but in my opinion too focused on its own features and away from the Python philosophy, while bpython seems more pythonic)

DreamPie: The Python shell you've always dreamed about! - another interesting alternative Python shell, this one as a GTK window. This opens up completely new possibilities, such as real popups as small graphical windows and direct graphical output. However, py-gtk for OS X is still rather shaky (like all GTK stuff currently, it's still alpha) and actually I prefer similar environments under OS X and Linux.

ZODB - a native object database for Python — ZODB v3.9.0 documentation - because I always forget: ZODB is also available standalone, without the Zope monster on top. And with direct access from Python, ZODB offers some very interesting features. Still one of the most developed real object databases for Python (but unfortunately still no general query language for the database to handle object sets more efficiently).

django-piston - I should also take a closer look at this, as it is supposed to facilitate the building of Web APIs with Django. And some of my company projects could benefit from it.

Front Range Pythoneering: Realizing Jython 2.5 - it's written further down there. Jython has a GIL as a funny Easter egg in the future module (which makes future language features available as "Beta"). So no GIL, just a joke. I would have been quite surprised otherwise.

Interactive Python GIL Visualization [dabeaz] - very interesting analysis of the effects of the GIL in multithreaded Python projects. Could Jython (no GIL, threading based on Java standards) be a help here?

maven-jython-plugin - Maven Jython Plugin - hmm, the Jython support for Maven is quite outdated - the artifact only targets 2.2.1 and the plugin only goes up to 2.2.1. It seems like an update is urgently needed.

Presenting django-devserver, a better runserver. - interesting idea, an extension of runserver that logs SQL statements and provides cache information. This could be quite interesting for my current Django project, as I sometimes produce somewhat more complex SQL there. (And yes, I'm tinkering with Django again, maybe something publishable will come out of it - but it's primarily a work project).

Faster or Lazier Pagination - interesting approach, simply not to determine the amount of sentences, but instead to assume a number of pages and update this when accessing later pages. A bit similar to some websites that only offer a section of the page list as navigation - for this you don't need to know how many pages there really are. Google also cheats by limiting the number of pages to a maximum. For large amounts of data with slow count(*) certainly very useful and possibly you could also combine this with cached maximum page numbers for different queries, so that the next time the assumption about the amount is already more precise.

mongoengine - Python API for accessing MongoDB with a structure similar to Django ORM.

The Definitive Guide to Jython — Jython Book v0.91 documentation - it is what it says on the tin. Refers to Jython 2.5.1 and is also available as (updated with additional content, the open source version of the book is not yet fully updated) dead tree from APress.

django-extensions - very useful tools for Django that plug into the manage. For example, a diff for SQL.

IronPython in Action: Front Page - didn't even notice, there is already a book about IronPython, the version of Python that runs in Microsoft's .NET environment. Could be interesting for some company projects, especially since there have already been initial successes of Django on IronPython as early as 2008 ...

Trellis - Library for event-driven programming in Python. The idea is to formulate rules instead of handcrafted callbacks that are applied to objects and automatically executed when corresponding changes occur. The system ensures a clean separation of these events, so that no deadlocks occur.

django-history-tables - could be interesting for a project at the company, there is also the requirement for a history of data changes.

pylint (analyzes Python source code looking for bugs and signs of poor quality.) (Logilab.org) - blogged for the colleagues, because when code standards are designed, it is also nice if you can at least automatically check part of them. In addition, pylint can perform (limited) static analysis of Python code and throw out warnings for parts that look strange.

matthiask's feincms - extensible CMS for Django. Looks very interesting, especially the quite compact extensibility for custom content types.

ReusableAppResources - Django - Trac - general starting point if you want to search for Django apps, from here you are referred to the various comparison lists.

stream – Lazily-evaluated, parallelizable pipeline - interesting small library for Python where streams are used as lazy evaluation lists for better parallelizability of code. And since Python is somewhat limited by the GIL when it comes to threads, models for using multiprocessing are also offered here (independent processes allow multiple cores to be used efficiently in Python, but at the cost of communication overhead between the processes). Certainly to be used with caution for various reasons - massive parallelism should rather be avoided with it, because since system threads and system processes are used, there is no way to have thousands of parallel processes (as would be possible with microthreads, for example). But still certainly useful for some problems.

entrian.com - goto for Python - goto for Python - goto and comefrom for Python. Yes, it was an April Fool's joke, but it actually works.

Nullege: A Search Engine for Python source code - very useful when you want to see how an API is used in various projects. Sometimes the documentation is a bit unclear and looking at example source code makes things clearer.

Python Package Index : promise 0.2.1 - quite a cool bytecode hack for Python that uses decorators to declare functions as "pure" or "constant" (or a few others) and thus enables optimizations of Python code. Specifically, expensive lookups can be avoided if you assure the compiler that within a function, for example, built-ins or named functions do not change dynamically but remain constant.

generator_tools - because you sometimes encounter the situation of wanting to save generators in Python (e.g. when simulating continuations or coroutines using generators and using them as the state of a running web workflow in a web framework), this module (based on a hack on bytecode introspection) works to a limited extent. Already interesting because of the insights it gives into the interpreter.

MetaPython Documentation - one of the things that always bring me from Python to Lisp are the nice Lisp macros, with which one can elegantly build embedded DSLs for various purposes that integrate well with the host language. With MetaPython, you might be able to achieve something similar with Python. At least all the components are there.

Socket Benchmark of Asynchronous Servers in Python - interesting article about the performance and scalability to high hit rates of various asynchronous servers in Python.

Invent with Python - interesting free book about Python programming. Among other things, PyGame is used in Chapter 16.

Haystack - Search for Django - and this is the integration of Whoosh in Django. There are others, but this one seems the most developed.

Whoosh - Full-text indexing in pure Python. Could be interesting for some projects.

IronPython - Release: 2.6 - this brings IronPython up to date with the Python 2 series. And allegedly, with a few changes, Django should also run directly on IronPython, although I haven't found any recent posts about this, only ones from 2008. .NET is not my favorite environment, but at work we will probably take a look at it in the long run, simply because integration with the rest of the Windows world should be easier with it than with the standard CPython.

ProjectPlan - unladen-swallow - Plans for optimizing Python - interesting status about Unladen Swallow, the Python version that builds on LLVM as JIT.

Python Package Index : python-daemon 1.5.2 - because I always need it from time to time and then always have to do it manually: this module helps to turn a Python script into a proper Unix daemon, with correct forking and PID file handling.

samuel's python-bert - and since I'm at it, also BERT in Python.

Code tutorial: make your application sync with Ubuntu One - Ubuntu One (the file and synchronization service from Canonical for Ubuntu) uses CouchDB internally (and the synchronization is based on CouchDB replication!) and this tutorial shows how to modify applications so that they work with CouchDB. Examples are in Python and also use some aspects of DBUS (Gnome), so it is generally a quite interesting tutorial for desktop programming under Linux. I think it is a good idea for Ubuntu One to rely on CouchDB replication - the mess of MobileMe in synchronization should be much better to handle.

clutchski's fileutils - makes Python even better for shell scripts by providing various basic commands as Python functions. Nice.

formsets and inline forms in Django - a similar problem came up at the company recently, so here's a blog post that might be the solution.

uWSGI - could be interesting for the Django projects at the company, sounds quite good from the description.

PyGoWave Server - I don't know if I already had this, but I just searched for it again on this occasion: an implementation of the Google Wave idea in Python. And the funny thing: the website underneath is built with Django!

Python moratorium and the future of 2.x [LWN.net] - a good summary of the current discussions around Python releases, specifically the discussion of whether 2.6 is the last 2.x Python, or whether the already existing 2.7 will still be released, whether there will be a 2.8 or more after that, or whether the switch to 3.x should be forced.

for post in leo.blog():: Django-Jython 1.0.0 released! - not unimportant for a project at work: Django-Jython is finished. And included is the Oracle client, which we would also urgently need for the project. Nice.

Lazy Pythonista: Diving into Unladen Swallow's Optimizations - Unladen Swallow is the Python variant for LLVM. It's looking more and more interesting.

Large Problems in Django, Mostly Solved: Search - interesting project: Haystack. An extension of Django to add full-text search with an interface very similar to the normal Django database interface.