Presentation Abstract

Brian Gershon, Alex Tokar and Kevin Audleman of Web Collective are nearing completion on a large 2-year long Django project - a flight coordination system for a volunteer run airline -- Air Charity.

Air Charity is a group of non-profits that connect volunteer pilots with people who need to fly for emergency medical reasons, disasters like Katrina, etc.

The Django system manages pilots, flights and passengers.

Presentation Overview

• Overview of Project / Demo -- Alex
• The Agile Process -- Brian
• Useful Techniques for Larger Projects with Multiple Developers -- Alex
• Powerful Programming Techniques -- Kevin
• Custom Authentication -- Brian
• Time for Questions

Demo of Air Charity

This system allows

• Prospective passengers to request air transportation
• Coordinators to create trips of up to 3 flightlegs for a passenger
• Pilots to view and request to fly a flightleg of a trip
• Coordinators to track and manage paperwork related to a trip

Some Details

• Lots of different models: pilots, trips, flights
• jQuery was critical in creating a responsive UI

The Agile Process

• Weekly iterations with two weekly 90-min meetings
• Monday: Demo of previous iteration; start new iteration. Retrospective. Measuring Velocity.
• Wednesday: Mid-iteration Preview; story grooming.
• Client standups. Dev standups.
• Expectation Challenge: Balancing up-front estimation with agile process. Need some, but not too much. Requires trust.
• Caution: Multitasking chews up velocity

The Agile Process: Iteration Planning

• We're using Agile Buddy (agilebuddy.com) to stage and track stories
• 

The Agile Process: Stories

Useful Techniques for Larger Projects with Multiple Developers - 1

Test Framework Important for Stable Software and Critical for Refactoring

• Core Model Terminology Changed 1 year in to project after a 3 month hiatus.
  • Flights -> Trips
  • Flights -> FlightLegs
  • FlighLegs -> FlightLegs
  • Screenshot of SVN after Refactor
• Adding workflow engine.
• Good to make frequent small improvements to code to reduce technical debt.

Useful Techniques for Larger Projects with Multiple Developers - 2

Keeping Developers in Sync

• Wasn't easy to run all tests without running Django tests, so created a "run all tests" script.
  
  
    

Useful Techniques for Larger Projects with Multiple Developers - 3

Keeping Developers in Sync - 2

• Process that worked for us
  • Get other's changes: Update your local from SVN
  • Make sure there are no broken tests ("Run all test" script)
  • Make your own changes (Development)
  • Make sure you didn't break anything: ("Run all test" script)
  • Did anyone else make changes in the meantime? svn up
  • Did they break anything? ("Run all test" script)
  • Check in your code
• Effectively, this is a "manual" Buildbot
• Do we also need continuous integration? (Buildbot, Hudson, etc)

Useful Techniques for Larger Projects with Multiple Developers - 4

Deployment and Test Data

• Fabric to update local dev instances, and various test and production servers.
  
• Management of fixture data -- test data, sample data, production data.

Powerful Programming Techniques - 1

• Make Your Models Useful With Properties
• Create Commands For Non-Browser Tasks
• Create Custom Object Managers For Complex Queries
• Write (Much) Less Code With ModelForms
• ModelFormSets: Awesome

Powerful Programming Techniques - 2

Make Your Models Useful With Properties

• Add the @property decorator before a function on a model
• This makes the ORM treat it like a field
• Example usage (with an instance of Trip as trip):   trip.departure_airport

Powerful Programming Techniques - 3

Create Commands For Non-Browser Tasks

• Commands reside in a folder management/commands within an app

Powerful Programming Techniques - 4

Create Commands For Non-Browser Tasks

• Commands subclass one of Django's command classes in django.core.management.base
• Example below: NoArgsCommand (doesn't take in any parameters from the command line)

Powerful Programming Techniques - 5

Create Commands For Non-Browser Tasks

• Commands are excuted from the command line
• Useful for cron jobs

Powerful Programming Techniques - 6

Create Custom Object Managers For Complex Queries

• Custom object managers are a subclass of django.db.models.Manager
• They represent a convenient place to put complex queries that are used in more than one view

Powerful Programming Techniques - 7

Create Custom Object Managers For Complex Queries

• Overwrite the default object manager in your class by redefining objects

Powerful Programming Techniques - 8

Create Custom Object Managers For Complex Queries

• Now you can access the query in any view easily

Powerful Programming Techniques - 9

Write (Much) Less Code With ModelForms

• First, the wrong way:
• Form level: Redefines the fields
• In the view: copy the fields from cleaned_data, type again creating a new instance

Powerful Programming Techniques - 10

Write (Much) Less Code With ModelForms

• The right way
• Form level: Only need to specify the Model class in Meta
• In the view: can use the ModelForm's save function to add/edit a record

Powerful Programming Techniques - 11

Write (Much) Less Code With ModelForms

• Result
• Without ModelForm, fields typed 4 times
• With ModelForm, fields typed 1 time

Extend the Power of the ORM - 1

• Example ERD

Extend the Power of the ORM - 2

• Existing ORM Functionality
• You most certainly already know about foreign key traversal: e.x. access a leg's trip:   leg.trip
• How about that Django automatically adds an object manager to the opposite end of a ForeignKey relationship? E.x.:   trip.leg_set.all()

Extend the Power of the ORM - 3

• You can (and should) extend the ORM Functionality
• Create properties to perform any traversals that aren't handled by the built in ORM functions that you think you will use in multiple views.
• Example 1: trip.departure_airport finds the first leg and retrieves it's departure airport
• Example 2: trip.primary_pilot finds the Leg2Pilot record, for the first Leg, that was approved and has a type "pilot"

Extend the Power of the ORM - 4

• Benefits to extending ORM
• Any functionality you might repeat across multiple views is centralized in one place.
• Less logic in views
• Less error prone code (code in one place, can write a simple test on the model method)
• As you develop the project, views get easier to write!

Extend the Power of the ORM - 5

• Benefits to extending ORM
• Example: this view accesses data across 4+ tables, including complicated lookups, but didn't require any additional coding because we wrote the model properties earlier in the development process

Extend the Power of the ORM

• Summary and Overall Django Philosophy
• The ORM is already powerful. Make it more powerful by extending your models with properties
• Abstract code out of views and into model properties, object manager methods, and other re-usable components
• Minimize duplicating code with ModelForms
• A few more thoughts that didn't fit anywhere else
• Don't put logic in templates. Makes it hard to write tests, and the view is a better place anyhow.
• Don't leave code hanging out in space.
  • Before you write a utils.py file and put helper functions there, ask: can I put this on a Model? Can I put this in a ModelManager? The answer is probably yes
• Tests are the lifeblood of a project. Write them!

Django Functionality: Custom Authentication

• Custom authentication backend so pilots could also login via their address. And also make sure expired pilots can't log in.
• Tour of custom authentication EmailBackend code
• Tour of custom authentication AuthenticationFormWithPilot form to add custom expiration logic (since we need to check before actual authentication happens)

Django Functionality: Custom Profile

• Needed custom properties in templates such as is_pilot, is_coordinator, is_administrator
• Implemented as a Context Processor for adding 'user_profile' dict in all templates.
• Tour of context_processors.py
• 

Wrapping Up

• Questions?
• Alex Tokar -- alext at webcollective.coop
• Brian Gershon -- briang at webcollective.coop
• Kevin Audleman -- kevina at webcollective.coop