What's new in Django community blogs?


Aug 23 2016 [Archived Version] □ Published at Latest Django packages added

Bridging React With Other Popular Web Languages

Aug 22 2016 [Archived Version] □ Published at tuts+

React is a view library written in JavaScript, and so it is agnostic of any stack configuration and can make an appearance in practically any web application that is using HTML and JavaScript for its presentation layer.

As React works as the ‘V’ in ‘MVC’, we can create our own application stack from our preferences. So far in this guide we have seen React working with Express, a Node ES6/JavaScript-based framework. Other popular Node-based matches for React are the Meteor framework and Facebook’s Relay.

If you want to take advantage of React’s excellent component-based JSX system, the virtual DOM and its super-fast rendering times with your existing project, you can do so by implementing one of the many open-source solutions.


As PHP is a server-side scripting language, integration with React can come in several forms:

Server-Side Rendering

For rendering React components on the server, there is a library available on GitHub.

For example, we can do the following in PHP with this package:

The power of combining React with any server-side scripting language is the ability to feed React with data, and apply your business logic on the server as well as the client side. Renovating an old application into a Reactive app has never been easier!

Using PHP + Alto Router

For an example application, take a look at this repository on GitHub.

Configure your AltoRouter as so:

With the AltoRouter setup serving your application’s pages for the routes specified, you can then just include your React code inside the HTML markup and begin using your components.


Ensure you include the React libraries and also place the HTML inside the body tag that will be served from your PHP AltoRouter app, for example:

Laravel Users

For the highly popular PHP framework Laravel, there is the react-laravel library, which enables React.js from right inside your Blade views.

For example:

The prerender flag tells Laravel to render the component on the server side and then mount it to the client side.

Example Laravel 5.2 + React App

Look at this excellent starter repository for an example of getting Laravel + React working by Spharian.

To render your React code inside your Laravel, set your React files’ source inside the index.blade.php body tag, by adding the following for example:


Using the ReactJS.NET framework, you can easily introduce React into your .NET application.

Install the ReactJS.NET package to your Visual Studio IDE via the NuGET package manager for .NET.

Search the available packages for ‘ReactJS.NET (MVC 4 and 5)’ and install. You will now be able to use any .jsx extension code in your asp.net app.

Add a new controller to your project to get started with React + .NET, and select “Empty MVC Controller” for your template. Once it is created, right click on return View() and add a new view with the following details:

  • View name: Index
  • View Engine: Razor (CSHTML)
  • Create a strongly-typed view: Unticked
  • Create as a partial view: Unticked
  • Use a layout or master page: Unticked

Now you can replace the default code with the following:

Now we need to create the Example.jsx referenced above, so create the file in your project and add your JSX as follows:

Now if you click Play in your Visual Studio IDE, you should see the Hello World comment box example.

Here’s a detailed tutorial on writing a component for asp.net.


By using react-rails, you can easily add React to any Rails (3.2+) application. To get started, just add the gem:

and install:

Now you can run the installation script:

This will result in two things:

  • A components.js manifest file in app/assets/javascripts/components/; this is where you will put all your components code.
  • Adding the following to your application.js:

Now .jsx code will be rendering, and you can add a block of React to your template, for example:

Ruby JSX

Babel is at the heart of the Ruby implementation of the react-rails gem, and can be configured as so:

Once react-rails is installed into your project, restart your server and any .js.jsx files will be transformed in your asset pipeline.

For more information on react-rails, go to the official documentation.


To install python-react, use pip like so:

You can now render React code with a Python app by providing the path to your .jsx components and serving the app with a render server. Usually this is a separate Node.js process.

To run a render server, follow this easy short guide.

Now you can start your server as so:

Start your python application:

And load up in a browser to see your React code rendering.


Add react to your INSTALLED_APPS and provide some configuration as so:


To add React to your meteor project, do so via:

Then in client/main.jsx add the following for example:

This is instantiating an App React component, which you will define in imports/ui/App.jsx, for example:

Inside the Headline.jsx, you use the following code:

Meteor is ready for React and has official documentation.

No More {{handlebars}}

An important point to note: When using Meteor with React, the default {{handlebars}} templating system is no longer used as it is defunct due to React being in the project.

So instead of using {{> TemplateName}} or Template.templateName for helpers and events in your JS, you will define everything in your View components, which are all subclasses of React.component.


React can be used in practically any language which utilises an HTML presentation layer. The benefits of React can be fully exploited by a plethora of potential software products.

React makes the UI View layer become component-based. Working logically with any stack means that we have a universal language for interface that designers across all facets of web development can utilise.

React unifies our projects’ interfaces, branding and general contingency across all deployments, no matter the device or platform restraints. Also in terms of freelance, client-based work or internally inside large organisations, React ensures reusable code for your projects.

You can create your own bespoke libraries of components and get working immediately inside new projects or renovate old ones, creating fully reactive isometric application interfaces quickly and easily.

React is a significant milestone in web development, and it has the potential to become an essential tool in any developer’s collection. Don’t get left behind.


Aug 20 2016 [Archived Version] □ Published at Latest Django packages added

Fork of Cookiecutter Django based on Zurb Foundation 6 front-end framework

django-screener - phone / interview screening app

Aug 19 2016 [Archived Version] □ Published at Latest Django packages added


Aug 19 2016 [Archived Version] □ Published at Latest Django packages added

Django package that provides Cloudinary storages for both media and static files as well as management commands for removing unnecessary files.


Aug 17 2016 [Archived Version] □ Published at python under tags  big data howtos pandas python

Serious practitioners of data science use the full scientific method, starting with a question and a hypothesis, followed by an exploration of the data to determine whether the hypothesis holds up. more>>

Welcome to the new members of the Django Software Foundation

Aug 17 2016 [Archived Version] □ Published at The Django weblog

Please welcome our new members. Some were nominated in recognition of their contributions to Django's code, some for their service on Django committees and work in other community organisations, and some in recognition of their contributions to the development of the international Django community.

All were seconded by the existing members of the DSF, and their election approved by the DSF Board.

Nominated 10th June

  • Sergey Fedoseev (Russia)
  • Berker Peksag (Turkey)
  • Alasdair Nicol (UK)
  • Jon Dufresne (Canada)
  • Marten Kenbeek (Netherlands)
  • Daniel Wiesmann (Portugal)
  • Alex Hill (Australia)
  • Michal Petrucha (Slovakia)

All are active technical contributors to Django's code base, with over 300 commits between them, not to mention the help they have offered to others on our support channels.

Jon Dufresne is also the newest member of the Django core development team.

Nominated 19th July

  • Paul Hallett (UK)
  • Lucie Daeye (France)

Both have made substantial contributions to the Django community, through their work on Django Girls and by taking on roles in Django community organisation. Lucie works for the Django Girls Foundation and Paul serves on the Django Project Code of Conduct committee. Both have worked hard to make the Django community ever more inclusive and good to be part of.

Nominated 1st August

  • Helen Sherwood-Taylor (UK)
  • Aisha Bello (Nigeria)
  • Anna Makarudze (Zimbabwe)
  • Humphrey Butau (Zimbabwe)
  • Jessica Upani (Namibia)
  • Loek van Gent (Netherlands)

All have been active in the Django community around the world, and were an important part of the success of PyCon Namibia this year. They're all continuing to work on the community's development, and are involved in efforts to bring new community conferences to fruition in Africa (in Zimbabwe and Nigeria just to name two).

Expanding our membership

The new members represent a substantial increase in the membership, of about 16%.

They also represent the way the Django Software Foundation is starting to recognise a more diverse community of people who can contribute in many different ways, and a genuinely global membership, including five more African members.

Thanks to those who nominated these new Django Software Foundation members, and thanks to our new members too, for their past, present and future contributions.


Aug 16 2016 [Archived Version] □ Published at Latest Django packages added

How to Merge Two Python Dictionaries

Aug 16 2016 [Archived Version] □ Published at tuts+

In a previous tutorial we learned about Python Dictionaries, and saw that they are considered unordered sets with a key/value pair, where keys are used to access items as opposed to the position, as in lists for instance.

In this quick tip, I'm going to show you how to concatenate (merge) two dictionaries together.

The Update() Method

Let's say we have the following two dictionaries:

How can we merge those two dictionaries in a single dictionary? A function we can use in this regard is update([other]). As stated in the Python documentation:

Update the dictionary with the key/value pairs from other, overwriting existing keys. Return None.
update() accepts either another dictionary object or an iterable of key/value pairs (as tuples or other iterables of length two). If keyword arguments are specified, the dictionary is then updated with those key/value pairs: d.update(red=1, blue=2).

So, to merge the above two dictionaries, we can type the following:


Say that you typed the following statement in order to view the results:

print dict2.update(dict1)

In this case you will get None! This is because the update() function does not return a new dictionary. In order to get the result of the concatenation, simply type the following:

print dict2

In which case, you will get the following output:

{'bookA': 1, 'bookB': 2, 'bookC': 3, 'bookD': 4, 'bookE': 5}

What if we did the following?

In this case, you will get the following output:

{'bookA': 1, 'bookB': 2, 'bookC': 2, 'bookD': 4, 'bookE': 5}

Notice that in the first case, dict2.update(dict1), we update the dictionary dict2 with the key/value pairs from dict1, and overwriting any existing keys. The existent key as we can notice is 'bookC', which will have the value 3 in this case, since we are updating with the key/value pairs from dict1. This will be reversed in the latter case, dict1.update(dict2), where we are updating the dictionary dict1 with key/value pairs from dict2.

However, there's an issue in using update() to merge two dictionaries. The issue lies in the fact that the original dictionary can be modified. In other words, in the first case for instance, dict2.update(dict1), the original version of dict2 could be modified, and in the latter case, dict1.update(dict2), the original version of dict1 could be modified. That is to say that you can use update() to merge two dictionaries if you are not interested in keeping the original version of the dictionary you need to update. By the original version here I mean retaining the value of the key.

Merging Two Dictionaries in a Single Expression

Another method you can use to merge two dictionaries, where you can perform such a task in a single expression, is as follows:

print dict(dict2, **dict1)

The output of this statement is:

{'bookA': 1, 'bookB': 2, 'bookC': 3, 'bookD': 4, 'bookE': 5}

Thus, dict1 overrides dict2. If we want dict2 to override dict1, we type:

print dict(dict1, **dict2)

The output in this case would be:

{'bookA': 1, 'bookB': 2, 'bookC': 2, 'bookD': 4, 'bookE': 5}

Retaining Key Values 

Returning to the previous issue of keeping the key values, how can we merge two dictionaries while keeping the originals of each dictionary?

A workaround for this can be as follows (taken from the answer in this StackOverflow thread):

The output in this case will be:

So, as you can see from this quick tip, it is very easy to merge two dictionaries using Python, and it becomes a bit more complex if we want to retain the values of the same key in each dictionary.

Analyzing Data

Aug 15 2016 [Archived Version] □ Published at python under tags  big data howtos python web development

My first Web-related job was in 1995, developing Web applications for a number of properties at Time Warner. When I first started there, we had a handful of programmers and managers handling all of the tasks. But over time, as happens in all growing companies and organizations, we started to specialize. more>>


Aug 13 2016 [Archived Version] □ Published at Latest Django packages added


Aug 13 2016 [Archived Version] □ Published at Latest Django packages added

A Django app for binding a user's Discord account to their Django user ID.

django-html-validator - now locally, fast!

Aug 12 2016 [Archived Version] □ Published at Peterbe.com

A couple of years ago I released a project called django-html-validator (GitHub link) and it's basically a Django library that takes the HTML generated inside Django and sends it in for HTML validation.

The first option is to send the HTML payload, over HTTPS, to https://validator.nu/. Not only is this slow but it also means sending potentially revealing HTML. Ideally you don't have any passwords in your HTML and if you're doing HTML validation you're probably testing against some test data. But... it sucked.

The other alternative was to download a vnu.jar file from the github.com/validator/validator project and executing it in a subprocess with java -jar vnu.jar /tmp/file.html. Problem with this is that it's really slow because java programs take such a long time to boot up.

But then, at the beginning of the year some contributors breathed fresh life into the project. Python 3 support and best of all; the ability to start the vnu.jar as a local server on http://localhost:8888 and HTTP post HTML over to that. Now you don't have to pay the high cost of booting up a java program and you don't have to rely on a remote HTTP call.

Now it becomes possible to have HTML validation checked on every rendered HTML response in the Django unit tests.

To try it, check out the new instructions on "Setting the vnu.jar path".

The contributor who's made this possible is Ville "scop" Skyttä, as well as others. Thanks!!

Controlling uncertainty on web applications and APIs

Aug 10 2016 [Archived Version] □ Published at Blog | Machinalis

“But it works fine on my machine!”

How many times have your heard that phrase? I’ve been working as a developer for over a decade and I can swear I heard it in every project I worked on. No matter how well you design your software and plan its deployments, almost always something unexpected happens.

Over the years, the industry has developed techniques and technologies to minimize the difference between the development and production environments. Right now we have scripted deployments, several container and virtualization solutions, and continuous integration, all working together to make sure that every step of the process is predictable. But even with all this in our toolbox, things still go wrong from time to time.

Here at Machinalis we provide services and work on projects with small startups and huge corporations (and everything in between), and although the resources and corporate structure might change, the goal remains the same: producing efficient high-quality products that fulfills its throughout its lifespan. Hence, the policies and techniques for deployment are pretty similar regardless of the size of the client, and it usually works just as we planned it...for a time.

Whether a multi-million dollar storage solution that’s about to give up the ghost or a clueless operator that uses a mission critical network to transfer several terabytes of media right in the middle of the launch of a product (both true stories, by the way); there are things that are beyond our control.

How can we make sure that our applications and APIs are robust enough to handle these situations? What can we do to test theories regarding these transient difficulties in infrastructure without access to the real environments?

The first answer is to design robust software. It’s not particularly hard and several ways of doing it have been thoroughly researched and documented. The next thing is setup logging properly. It’s the easiest thing to do but it is also frequently overlooked.

The next thing is test for less than ideal situations. Enter chaos.

When we need to introduce simulated network problems into a project, we rely on chaotic proxies. These proxies sit in between components that need to communicate through a network, and they cause predictable problems like delays, disconnections and, in the case of TCP proxies, packet dropouts and other low-level network problems.

So far we’ve used mostly Vaurien due to its flexibility, ease of use, and the fact that is written in Python (which is alwasy a plus). Others we can mention are comcast, toxiproxy, and clumsy.

Let’s illustrate the process with a simple example. We have a very simple RESTful web API that serves a one-page web application. We want to make sure the application can handle transient problems with the API, so we need to set-up the proxy between the app and the API.

First we’ll hit the API using ApacheBench to get an idea of how it works under normal circumstances:

Server Software:        nginx/1.4.6
Server Hostname:        localhost
Server Port:            8000

Document Path:          /api/items/
Document Length:        2817 bytes

Concurrency Level:      1
Time taken for tests:   3.909 seconds
Complete requests:      500
Failed requests:        0
Total transferred:      1519000 bytes
HTML transferred:       1408500 bytes
Requests per second:    127.91 [#/sec] (mean)
Time per request:       7.818 [ms] (mean)
Time per request:       7.818 [ms] (mean, across all concurrent requests)
Transfer rate:          379.49 [Kbytes/sec] received

Connection Times (ms)
        min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:     7    8   0.5      8      11
Waiting:        7    8   0.5      7      11
Total:          7    8   0.5      8      11
ERROR: The median and mean for the waiting time are more than twice the standard
       deviation apart. These results are NOT reliable.

Percentage of the requests served within a certain time (ms)
  50%      8
  66%      8
  75%      8
  80%      8
  90%      8
  95%      9
  98%      9
  99%     10
 100%     11 (longest request)

Now we want 20% of the calls to fail, so we set-up vaurien:

$ vaurien --protocol http --proxy --backend localhost:8000 --behavior 10:error
2016-08-08 11:54:58 [18580] [INFO] Starting the Chaos TCP Server
2016-08-08 11:54:58 [18580] [INFO] Options:
2016-08-08 11:54:58 [18580] [INFO] * proxies from to localhost:8000
2016-08-08 11:54:58 [18580] [INFO] * timeout: 30
2016-08-08 11:54:58 [18580] [INFO] * stay_connected: 0
2016-08-08 11:54:58 [18580] [INFO] * pool_max_size: 100
2016-08-08 11:54:58 [18580] [INFO] * pool_timeout: 30
2016-08-08 11:54:58 [18580] [INFO] * async_mode: 1

And run ab against the proxy port:

Server Software:
Server Hostname:        localhost
Server Port:            8005

Document Path:          /api/items/
Document Length:        188 bytes

Concurrency Level:      1
Time taken for tests:   3.854 seconds
Complete requests:      500
Failed requests:        471
   (Connect: 0, Receive: 0, Length: 471, Exceptions: 0)
Non-2xx responses:      102
Total transferred:      1241946 bytes
HTML transferred:       1144942 bytes
Requests per second:    129.74 [#/sec] (mean)
Time per request:       7.707 [ms] (mean)
Time per request:       7.707 [ms] (mean, across all concurrent requests)
Transfer rate:          314.72 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:     1    8   3.8      9      36
Waiting:        1    8   3.8      9      36
Total:          1    8   3.8      9      36

Percentage of the requests served within a certain time (ms)
  50%      9
  66%      9
  75%      9
  80%     10
  90%     10
  95%     11
  98%     12
  99%     13
 100%     36 (longest request)

So we got 106 out 500 abnormal responses (close to our 20% target).

Vuarien supports other protocols as well, which makes it ideal for the task of introducing uncertainty into any modern project that integrates multiple back-ends, but it is not without its problems; it only supports Python 2, so you would have to use separate virtualenvs for Python 3 project, it lacks flexibility for some use cases, and it is another component that you have to integrate into your testing architecture which adds complexity.

What if all you wanted was a simple way to introduce uncertainty into an API to test a single-page app? If you’re using Django, we’ve got a solution for you.

Last week Django 1.10 was released, and with it, a new middleware system. While reviewing the release notes we realized that this was a good opportunity to fill a gap in our toolbox and learn to use the new features in the process; so we decided to create django_uncertainty.

django_uncertainty is a Django 1.10 middleware that allows developers to introduced the kinds of problems we described above to allow testing less than favorable conditions in the local development environment.

What makes it different than Vaurien or any other proxy?

  • It is dead simple and can be easily extended.
  • It has no external dependencies.
  • You can define behaviors based on knowledge of the internal structure of the application.
  • It only works with Django 1.10 or later.
  • It only supports HTTP.
  • It can only be placed in front of the target application.

As you can see, it has its limitations, but we think it can be useful under certain conditions. Let’s see it in action.

Same as before, we want 20% of the requests to fail, but now we want 10% of those to be Internal Server Errors (500), 5% to be Forbidden (403) and 5% to be Not Found (404). Assuming that the middleware has been properly set up (it’s explained in the package documentation), you can declare this particular behavior with the DJANGO_UNCERTAINTY settings variable:

import uncertainty as u
DJANGO_UNCERTAINTY = u.random_choice([
    (u.server_error(), 0.1),
    (u.forbidden(), 0.05),
    (u.not_found(), 0.05)

Let us fire up ab once again to see how the middleware performs:

Server Software:        nginx/1.4.6
Server Hostname:        localhost
Server Port:            8000

Document Path:          /api/items/
Document Length:        2817 bytes

Concurrency Level:      1
Time taken for tests:   3.401 seconds
Complete requests:      500
Failed requests:        97
   (Connect: 0, Receive: 0, Length: 97, Exceptions: 0)
Non-2xx responses:      97
Total transferred:      1242483 bytes
HTML transferred:       1135251 bytes
Requests per second:    147.01 [#/sec] (mean)
Time per request:       6.802 [ms] (mean)
Time per request:       6.802 [ms] (mean, across all concurrent requests)
Transfer rate:          356.76 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:     1    7   2.7      8      33
Waiting:        1    7   2.7      7      33
Total:          1    7   2.7      8      33

Percentage of the requests served within a certain time (ms)
  50%      8
  66%      8
  75%      8
  80%      8
  90%      8
  95%      9
  98%     10
  99%     10
 100%     33 (longest request)

The count for each specific error code is not shown, but we can extract the values from the log file. Here’s the final tally.

Status Code Count Percentage
200 403 0.81
500 51 0.10
403 15 0.03
404 31 0.06

The numbers don’t match our specification exactly due to the usage of a random number to chose which behavior to activate.

Let us change the specification a bit. Now we want to delay requests by half a second, but only those which use PUT or PATCH requests and go through under the /api/ path and we want the requests to go through as normal

import uncertainty as u
DJANGO_UNCERTAINTY = u.cond(u.path_is('^/api') & (u.is_post | u.is_method('PATCH')), u.delay(u.default(), 0.5))

You can read the documentation to see what other behaviors and conditions can be used to control the outcome of the requests. We tried our best to provide the tools to describe the most common scenarios, but if you think there are others that we can cover, feel free to create a ticket in the GitHub repository with a description of the situation you want to specify.

If you want to try a live demo of the middleware, we’ve created a sample that exposes a RESTful API using Django Rest Framework. You can get the code on GitHub and there’s also a Vagrantfile with everything already set-up for you.

Drop us a comment with your take on this matter. We’re interested to learn about other situations were the unexpected happened and how was the problem deal with. Feedback on the blogpost and the code is always welcomed as well.

Dritte Hamburger Python Unconference

Aug 10 2016 [Archived Version] □ Published at Arnes Blog under tags  django hamburg opensource python pyunconf

Python Unconference Hamburg

Vom 09. bis 11. September 2016 findet die 3​. Python Unconference​ Hamburg an der Technischen Universität Hamburg-Harburg (TUHH) statt.

Erwartet werden über 100 Python­-User bzw. Developer aus Hamburg und dem Rest der Welt. Von "Greenhorns" bis zu "proven Experts" aus den Bereichen Mathematik, Data Science, System­-Administration und DevOps bis hin zu Web­-Development und Python­-Core-­Entwicklung werden alle nur erdenklichen Facetten der Python­-Welt vertreten sein.

Wie in den letzten Jahren findet die Unconference am Samstag und Sonntag im Barcamp-Stil statt, mit Vorträgen und Diskussionen aus allen Bereichen der Python Welt. Am Freitag gibt es wieder Raum für Sprints, Tutorials und Workshops. Das aktuelle Freitags-Programm findet Ihr hier .

Tickets gibt es hier.

Mehr Informationen gibt es unter www.pyunconf.de.

django-planet aggregates posts from Django-related blogs. It is not affiliated with or endorsed by the Django Project.

Social Sharing


Tag cloud

admin administration adsense advanced ajax amazon angular angularjs apache api app appengine app engine apple application security aprendiendo python architecture articles asides audrey authentication automation backup bash basics best practices binary bitbucket blog blog action day blogging book books buildout business c++ cache capoeira celery celerycam celerycrawler challenges chat cherokee choices class-based-views cliff cloud cms code codeship codeship news coding command community computer computers computing configuration continuous deployment continuous integration couchdb coverage css custom d data database databases db debian debugging deploy deployment deployment academy design developers development devops digitalocean django django1.7 django cms djangocon django framework django-nose django-readonly-site django-rest-framework django-tagging django templates django-twisted-chat django web framework tutorials documentation dojango dojo dotcloud dreamhost dughh easy_install eclipse education elasticsearch email encoding english error events expressjs extensions fabric facebook family fashiolista fedora field file filter fix flash flask form forms frameworks friends fun gae gallery games geek general gentoo gis git github gmail gnome google google app engine guides gunicorn hack hackathon hacking hamburg haskell heroku holidays hosting howto how-to how-tos html http i18n image imaging indifex install installation intermediate internet ios iphone java javascript jobs journalism jquery json justmigrated kde linear regression linkedin linode linux login mac machine learning mac os x math memcached mercurial meta migration mirror misc model models mod_wsgi mongodb months mozilla multi-language mvc mysql nelenschuurmans newforms news nginx nodejs nosql ogólne openshift opensource open source open-source operations orm osx os x ottawa paas packages patterns pedantics pelican performance personal philosophy php pi pil pinax pip piston planet plone plugin pony postgis postgres postgresql ppoftw presentation private programmieren programming programming & internet project projects pycharm pycon pygrunn pyladies pypi pypy python python3 queryset quick tips quora rabbitmq rails rant ratnadeep debnath reactjs redis refactor release request resolutions rest reusable app review rhel rtnpro ruby ruby on rails scala scaling science screencast script scripting security server setup simple smiley snaking software software collections software development south sphinx sql ssh ssl static storage supervisor support svn sysadmin tag tag cloud talk nerdy to me tastypie tdd techblog technical technology template templates template tags test testing tests tip tips tools tornado transifex travel tumbles tutorial tutorials twisted twitter twoscoops typo3 ubuntu uncategorized unicode unittest unix use user authentication usergroup uwsgi uxebu virtualenv virtualenvwrapper web web 2.0 web application web applications web design & development webdev web development webfaction web framework websockets whoosh windows wordpress work workshop yada znc zope