today i will share my idea on django form validation. In a normal way @ something that you learn
from django docs maybe you will do like this

from django.shortcuts import render_to_response
from django import forms

class BiodataForm(forms.Form):
    firstname = forms.CharField(widget = forms.TextInput(), required = True)
    lastname = forms.CharField(widget = forms.TextInput(), required = True)
    dob = forms.DateField(required = True)

def biodataHandler(request):
    if request.method == 'POST':
        form = BiodataForm(request.POST)
        if form.is_valid():
            # do something, submit to db,etc..
        else:
            # display errors
    else:
        form = BiodataForm()
        # display back the form in template

that is a static way on form validation handling..you will repeat it on the other function,right?
remember the DRY(Don’t Repeat Yourself) principle..
my idea is i will create a shortcut function to dynamically handle any form validation,ok lets begin

let say i have a biodata model (note that i use separate model in models folder)
myproject/models/biodata.py

from django.db import models

class Biodata(models.Model):
    firstname = models.CharField(max_length = 32, null = False, blank = False)
    lastname = models.CharField(max_length = 32, null = False, blank = False)
    dob = models.DateField(null = False, blank = False)

and the shortcuts function
myproject/lib/shortcuts.py

def validateform(form, request):
    if request.method.lower() == 'post':
        f = form(request.POST)
        if not f.is_valid() and f.errors:
            return (f, f.errors)
        elif f.is_valid():
            return (f, None)
    else:
        f = form()
        return (f, None)

the controller (note that i put all controllers in controllers folder)
myproject/controllers/biodata.py

from django.shortcuts import render_to_response
from django.views.decorators.http import require_http_methods
from django import forms
from myproject.models.biodata import Biodata
from myproject.lib.shortcuts import validateform

class BiodataForm(forms.ModelForm):
    class Meta:
        model = Biodata

@require_http_methods(["GET", "POST"])
def biodataHandler(request):
    form, errors = validateform(BiodataForm, request)
    data = {}
    if errors:
        data.update({
            'errors': errors
        })
        # display errors
    elif not errors and form.data:
        # do something, submit to db,etc..
    data.update({'form': form})
    return render_to_response('biodata.html', data, mimetype='text/html')

that’s it..

runserver.py for tornado wsgi server

import os, sys
import django.core.handlers.wsgi
from tornado import httpserver, ioloop, wsgi

def runserver():
    app_dir = os.path.abspath(os.path.dirname(__file__))
    sys.path.append(os.path.dirname(app_dir))
    os.environ['DJANGO_SETTINGS_MODULE'] = 'myproject.settings'
    application = django.core.handlers.wsgi.WSGIHandler()

    container = wsgi.WSGIContainer(application)
    server = httpserver.HTTPServer(container)
    server.listen(80)
    try:
        ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        sys.exit(0)

if __name__ == '__main__':
    runserver()

runserver.py for fapws wsgi server

import os, sys
import fapws._evwsgi as evwsgi
from fapws import base
from fapws.contrib import django_handler

def runserver():
    app_dir = os.path.abspath(os.path.dirname(__file__))
    sys.path.append(os.path.dirname(app_dir))
    os.environ['DJANGO_SETTINGS_MODULE'] = 'myproject.settings'

    def application(environ, start_response):
        response = django_handler.handler(environ, start_response)
        return [response]

    evwsgi.start('0.0.0.0', '80')
    evwsgi.set_base_module(base)
    evwsgi.wsgi_cb(('', application))
    evwsgi.set_debug(0)
    try:
        evwsgi.run()
    except KeyboardInterrupt:
        sys.exit(0)

if __name__ == '__main__':
    runserver()

runserver.py for gevent wsgi server

import os, sys
import django.core.handlers.wsgi
from gevent import wsgi

def runserver():
    app_dir = os.path.abspath(os.path.dirname(__file__))
    sys.path.append(os.path.dirname(app_dir))
    os.environ['DJANGO_SETTINGS_MODULE'] = 'myproject.settings'
    application = django.core.handlers.wsgi.WSGIHandler()

    server = wsgi.WSGIServer(('', 80), application, spawn = None)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        server.stop()
        sys.exit(0)

if __name__ == '__main__':
    runserver()

**this three servers gives better performance and low memory usage than apache with mod_wsgi server..
for production use, the script should be run as service

myproject/
	__init__.py
	hello.py
	lib/   __init__.py   rest.py   shortcuts.py
	manage.py
	settings.py
	urls.py

take note that hello.py and lib package(folder) is my code,not came with django-admin.py startproject myproject

ok,let me explain how we implement REST in this django project..
in the lib package,rest.py have some classes that will handle REST method and in shortcuts.py there is some functions that will handle json request and response

file : myproject/lib/rest.py

# myproject/lib/rest.py

from django.http import HttpResponseNotAllowed

class RESTmethod(object):
    methods = ['GET','POST','PUT','DELETE']

    def __call__(self, request, *args, **kwargs):
        callback = getattr(self, request.method.lower(), None)
        if callback:
            return callback(request, *args, **kwargs)
        else:
            return HttpResponseNotAllowed(self.get_allowed_methods())
    def get_allowed_methods(self):
        return [method for method in self.methods if hasattr(self, method.lower())]

class StatusCode(object):
    OK = 200
    NOT_FOUND = 404
    # add more status code according to your need

file : myproject/lib/shortcuts.py

# myproject/lib/shortcuts.py

from myproject.lib.rest import StatusCode
from django.utils import simplejson as json
from django.http import HttpResponse

def JSONResponse(data = None, status = StatusCode.OK):
    if data is None:
        return HttpResponse(status)
    if data and type(data) is dict:
        return HttpResponse(json.dumps(data, indent = 4, encoding = 'utf-8', sort_keys = True), \
            mimetype = 'application/json', status = status)
    else:
        return HttpResponse(status = StatusCode.NOT_FOUND)

def getJSONObject(request):
    data = None
    if request.raw_post_data:
        try:
            data = json.loads(request.raw_post_data.replace("'","\""), encoding = 'utf-8')
        except:
            data = data
    if data and type(data) is dict:
        return data

then in hello.py

file : hello.py

# myproject/hello.py

from myproject.lib.rest import RESTmethod, StatusCode
from myproject.lib.shortcuts import getJSONObject, JSONResponse

class Hello(RESTmethod):
    def get(self, request):
        requestdata = getJSONObject(request)
        if requestdata:
            return JSONResponse(requestdata)
        return JSONResponse(status = StatusCode.NOT_FOUND)

    def post(self, request):
        requestdata = getJSONObject(request)
        if requestdata:
            return JSONResponse(requestdata)
        return JSONResponse(status = StatusCode.NOT_FOUND)

    # add put, delete functions yourself..function is according to methods in RESTmehtod class in lowercase name

lastly in urls.py

file : myproject/urls.py

# myproject/urls.py

from django.conf.urls import *
from myproject.hello import Hello

urlpatterns = patterns('',
    (r'/hello$', Hello()),
)

that’s all,the project is ready for testing..but dont forget to append your parent folder of myproject in django.wsgi script..see the guide here

you can test it with googlechrome rest client Chrome REST Client or firefox rest client Firefox REST Client
remember to test with json request!
all the best guys!