This appears to have been the correct choice, as I’ve already acquired a confident grasp of the concepts and techniques of Django in less than a few days of playing with it (granted; with the odd reference look-up on http://www.djangobook.com/ and http://docs.djangoproject.com/en/dev/).

However, last night it all went a bit wrong when I upgraded my local version of Django from 0.96 to 1.0…

Most of my issues were due to the fact that some of the code in the examples, included in Practical Django Projects, was now out of date. However, I had expected this (thanks to warnings from Cyril Doussin and Steve Webster) and went about fixing the problems using the informative Porting Guide on the Django documentation site.

Following my extensive fixes, I was still experiencing issues when decoupling the Admin class from its relevant model. In most cases, this was a relatively easy process, but in one particular situation, where I had used edit_inline and needed to update the method to use the new InlineModelAdmin objects, I had a slightly confusing issue: I needed to add the InlineModelAdmin object to one of the django.contrib applications — FlatPage — to get the SearchKeyword application to work.

After a short period googling, I found an interesting, well-written blog post by Jason Broyles, “Add InlineModelAdmin to a django.contrib app“. Unsurprisingly, it seemed others had had exactly the same issue.

Jason’s final model.py and admin.py files were as follows:

# models.py

from django.db import models
from django.contrib.flatpages.models import FlatPage

class SearchKeyword(models.Model):
    keyword = models.CharField(max_length=50)
    page = models.ForeignKey(FlatPage)

    def __unicode__(self):
        return self.keyword

# admin.py

from django.contrib import admin
from cms.search.models import SearchKeyword
from django.contrib.flatpages.models import FlatPage
from django.utils.translation import ugettext_lazy as _

class SearchKeywordInline(admin.StackedInline):
    model = SearchKeyword
    extra = 3
    max_num = 6

class FlatPageAdmin(admin.ModelAdmin):
    fieldsets = (
        (None, {'fields': ('url', 'title', 'content', 'sites')}),
        (_('Advanced options'), {'classes': ('collapse',), 'fields': ('enable_comments', 'registration_required', 'template_name')}),
    )
    list_display = ('url', 'title')
    list_filter = ('sites', 'enable_comments', 'registration_required')
    search_fields = ('url', 'title')
    inlines = [SearchKeywordInline,]

admin.site.unregister(FlatPage)
admin.site.register(FlatPage, FlatPageAdmin)

Jason followed these examples with the following explanation:

The above admin.py file will make it so the SearchKeyword model is accessible in the FlatPages admin interface. It does this by first creating the SearchKeywordInline class and adding it to a new FlatPage ModelAdmin function. I also didn’t want to loose out on any of the extra options from the default django.contrib.flatpages ModelAdmin so I copied lines 6 and 14-20 from it and added the code to my file. Line 23 then unregisters the default FlatPage ModelAdmin and line 24 registers this new one with my inlines included.

This solution fixed my problems, however I was concerned that copying and pasting code from django.contrib.flatpages ModelAdmin to admin.py was a massively inelegant solution. With that in mind, I came up with the following solution using inheritance:

# admin.py

from django.contrib import admin
from cms.search.models import SearchKeyword
from django.contrib.flatpages.models import FlatPage
from django.contrib.flatpages.admin import FlatPageAdmin
from django.utils.translation import ugettext_lazy as _

class SearchKeyword_Inline(admin.TabularInline):
	model = SearchKeyword
	extra = 3
	max_num = 6

class FlatPageAdmin(FlatPageAdmin):
 	inlines = [SearchKeyword_Inline]

admin.site.unregister(FlatPage)
admin.site.register(FlatPage, FlatPageAdmin)

This worked perfectly.

As a final note, I’d just like to thank Jason for posting his solution; without that much needed information, I probably would have spent a lot more time trying to fix the issue than was really required. It just goes to show that developers that blog are a huge benefit to confused developers everywhere.

Sure, JavaScript has it’s flaws and shortcomings; but then, so does my wife and I still love her! (Although, obviously she’d disagreed. She’d probably have something to say about being compared to a programming language too – just as well she doesn’t read my blog then, eh?)

Anyhoo, recently I’ve had the pleasure of working rather extensively with my afore-mentioned language du jour. For this reason, I needed to dig out the reference material and, since I haven’t blogged anything remotely useful for a while, I thought I’d share my choice cuts with the blogosphere.

Books

Firstly, no JavaScript programmer’s library is complete without the excellent “JavaScript: The Definitive Guide“, by David Flanagan, and published by O’Reilly. If you’re programming JavaScript in any way, you should get this book – it contains excellent explanations for all the characteristics of the language as well as providing a great reference section.

My next favourite book when developing with JavaScript is “The JavaScript Anthology: 101 Essential Tips, Tricks and Hacks“, by James “Brothercake” Edwards and Cameron “The Man In Blue” Adams, and published by the excellent SitePoint. This book provides a wealth of useful tips on various problems faced everyday when programming with JavaScript. It’s an invaluable reference source and it’s been a permanent feature on my desk since I bought it!

Next up is Christian Heilmann‘s “Beginning JavaScript with DOM Scripting and Ajax“, published by Apress. This book is a great read no matter what your skill level, and will teach you the basics as well as some advanced techniques. I really like this book and, although I may be slightly biased since he sits about 3 desks away from me, Chris is a fount of information regarding my favourite language.

Lastly, no list of JavaScript recommended reading would be complete without a book by Jeremy Keith; and since he’s latest hasn’t been released yet, you should definitely take a look at “DOM Scripting: Web Design with JavaScript and the Document Object Model“, published by Friends of ED. Although this book only really covers DOM Scripting (which is just a small segment of what JavaScript is capable of), it covers it well and, since most developers will only really require this sort of implementation, it’s certainly one for the bookshelf!

Video

With the dawning of the YouTube era, it’s nice to see that online video is finally becoming a staple part of our brain-food. Further to this, Yahoo! have incorporated an entire theatre of informative videos within the YUI section of the Yahoo! Developer Network. Imaginatively entitled YUI Theatre, it’s a good place to watch some informative lectures.

As far as JavaScript is concerned, you should probably watch the following:

Douglas Crockford — “The JavaScript Programming Language”

Yahoo! JavaScript Architect Douglas Crockford provides a comprehensive introduction to the JavaScript Programming Language in this four-part video:

1. Part 1: 31 minutes
2. Part 2: 31 minutes
3. Part 3: 29 minutes
4. Part 4: 20 minutes

Douglas Crockford — “Advanced JavaScript”

Yahoo! JavaScript Architect Douglas Crockford lectures on the nuances of the JavaScript programming language in this three-part video:

1. Part 1: 31 minutes
2. Part 2: 25 minutes
3. Part 3: 11 minutes

Douglas Crockford — “An Inconvenient API: The Theory of the DOM”

Yahoo! JavaScript Architect Douglas Crockford discusses the nexus between JavaScript and the browser, exploring the history of the BOM and DOM APIs and their impact on frontend engineering today. This presentation is archived in three parts:

1. Part 1: 31 minutes
2. Part 2: 21 minutes
3. Part 3: 26 minutes

Eric Miraglia — “Applying Ajax: Speeding the Journey from Idea to Information”

Eric Miraglia, YUI engineer and technical evangelist, addresses the RealWorld Ajax conference in San Jose in April 2006. Miraglia’s talk focuses on applying Ajax techniques to power real-world interaction problems and looks at autocomplete as a pattern that illustrate’s the power of XMLHttpRequest.

Web

Finally, as web developers, one would hope we’d embrace the internet as a teaching tool. To this end, you might like to take a look at some of the following sites:

• Douglas Crockford’s JavaScript site – Contains a great set of tutorials, musings, and development recommendations.
• Mozilla Developer Centre – A fantastic reference resource on all subjects; from JavaScript itself, through to the DOM.
• W3Schools JavaScript Tutorial – A great tutorial for beginners, the W3Schools site also has a nice reference secton.
• Sitepoint’s JavaScript 101 – A good tutorial. Searching through Sitepoint’s archive could also be recommended!
• A List Apart’s Code Topic – A List Apart often publish tutorials involving JavaScript. The resource is too large to recommend a single piece. You’re better off searching the archive yourself.
• Object Oriented Javascript – A bit of harmless self-promotion here. My tutorial still seems to be popular, and continues to be the largest entry point to my site!