Let’s say you have a template with the following line:

<link rel="stylesheet" type="text/css" href="/site_media/css/style.css" />

Every time the page loads the browser cache will think it’s seen the file before and reload the cached version from disk. One solution is to dynamically generate the link so that the browser thinks it is loading a new file every time. One way to do this without actually making a new file every time (you could just rename your CSS file every time you update it, but that’s painful) is to pretend you’re passing some parameters to the CSS file, like this:

<link rel="stylesheet" type="text/css" href="/site_media/css/style.css?12345" />

The trick is to generate a new fake parameter every time the page loads. Django templates make this easy by allowing us to generate a Unix timestamp (the number of seconds since a specific point in history) which we can attach to our link.

To do this we use the “now” template tag. In your template file, update the stylesheet line to the following:

<link rel="stylesheet" type="text/css" href="/site_media/css/style.css?{% now "U" %}" />

This will generate a line like the following every time the page is loaded:

<link rel="stylesheet" type="text/css" href="/site_media/css/style.css?1249948982" />

Voila! Automatically-refreshing stylesheets. You don’t have to make any changes to your stylesheet to use this.

This is a little inefficient, and if you have a super busy site and a very big stylesheet this could add an extra fair bit of bandwidth usage to your server(s). To get around this you could just change the “now” tag usage to generate a daily stamp (see the “now” tag docs), e.g. style.css?20090712, in which case the client browser should only reload it once per day.

Yesterday I was at work and trying to track down an Open Source hex editor so I thought I’d pop into SourceForge and browse their extensive software database.  Even though other Open Source project hosting services have been gaining a lot of momentum lately SourceForge is still the first place I turn to when looking for Open Source apps.  It still has the largest legacy range of software of any similar site.  Anyway, I happened to be using IE 6 because it was part of the particular build on the PC I was using and, to my surprise, up popped a little information bar at the top of the screen, stating:

Your browser isn’t supported, so some things might not work as expected.  Please upgrade to a newer version of IE, or to Firefox.

The web developer in me shrieked with joy, but the objective observer quickly overruled and made me think of all the corporates out there still on IE6.  I can certainly speak for most of the clients I’ve worked with at the company I work for.  Browser usage is a reasonably difficult metric to measure accurately in a big-picture sense, but I think it’s fair to say that we should still make some attempt at supporting it.  It seems that the good folks at SourceForge quite literally haven’t even tried their site in IE6, even once:

SourceForge.net in IE6 - Click to enlarge

Compare that to IE 7 & 8 (it looks the same in both):

SourceForge.net in IE7 - Click to enlarge

I should point out that it is somewhat hypocritical of me to condemn this sort of behaviour, since I explicitly do not support any version of IE lower than 7 on the new Tubecaster site, but I would only do that on my own personal sites and never for a business or any other client.

Believe me when I say that I understand the pain of developing for IE6 – the constant hair pulling, beating and maiming of web standards, and horrors such as HasLayout – but I really believe that with the tools and knowledge available to us now, like these sites[1], which detail common known IE bugs and layout quirks, to Microsoft’s free Virtual PC 2007 and their free Virtual PC Windows XP IE images[2], there is little excuse for web developers to not make at least some effort to get their sites behaving reasonably well in IE6.

I’m not talking about getting everything pixel-perfect.  Nobody that uses your websites for their intended purposes is going to notice the 2px misalignment on that floating image, or slightly overweight sidebar.  As much as those extra pixels will scream at you, taunt you, every time you see them in IE6, just spare a thought for those users who, for one reason or another, cannot yet upgrade.

Don’t despair – Microsoft is well on the way to giving IE6 the boot, once and for all.

]]> http://www.wkoorts.com/wkblog/2009/05/20/sourceforge-drops-ie-6-support/feed/ 3 http://www.wkoorts.com/wkblog/2009/05/09/server-fault-private-beta/ http://www.wkoorts.com/wkblog/2009/05/09/server-fault-private-beta/#comments Fri, 08 May 2009 22:07:10 +0000 Wayne http://www.wkoorts.com/wkblog/?p=105 Following on from the wildly successful Stack Overflow programming questions and answers website, Jeff Atwood and Joel Spolsky have launched Server Fault, a questions and answers site following the same format but now for “system administrators and IT professionals” (currently in Private Beta, click here for sign-up instructions).

I’ve been using Stack Overflow for about 5 months and I absolutely love it. It has become the definitive, and I dare say de facto standard, questions and answers one-stop-shop for programmers. You can post a question for just about any programming topic and receive an answer within minutes, sometimes even seconds. This removes an old hassle with posting questions on Web 1.0-style forums where you had to wait impractically long lengths of time to receive answers.

These sites don’t just follow any standard Q&A format either.  Just take a look at the diagram on the about page of either site and you’ll see that they’re a deliciously freakish Wiki/Blog/Forum blend.

One of the things I love about boths sites is their innovative karma and badge system, where users are rewarded by the community for making valuable contributions.  This gives users a reputation score which appears next to their name wherever it appears on the site.  This can be used as an assessment of someone’s overall standing in the community.  Badges are awarded for special achievements like providing an especially highly-rated answer or for being recognised as an expert in a particular technology.

Of course possibly the most important feature of boths sites is that you don’t need to be logged in to ask or answer questions.  This removes yet another annoying hurdle for the casual help-seeker.

I encourage everyone in IT, be it programming or otherwise, to sign up to at least one of these – you won’t look back.

-Wayne

.

I’ve just launched a new website for Tubecaster.  The new site was created with Django, with which I’m extremely impressed.

The new site also contains bug reporting and feature request links.

-Wayne

I’ve discovered a neat trick for making better use of the limited space available on the Bookmarks Toolbar: Favicons.  When you add a link to the Bookmarks Toolbar and have visited the link at least once (and let the page load fully) Firefox will retrieve the favicon from the website and attach it to the bookmark.  What you can do now is rename the bookmark (right-click -> Properties -> Name) and just remove the name altogether.  Thus:

becomes…

…reducing it to less than half the width!

Now you fit more than twice as many links on the toolbar!  Unfortunately there are still many sites that don’t publish favicons but most medium to large websites do.

-Wayne

Download Python Line Counter

Sample usage:

cmd> plc.py tubecore.py tubewx.py tubewxdialogs.py

Input files:
tubecore.py
tubewx.py
tubewxdialogs.py

Total lines:   1510
Code lines:    1111
Comment lines: 139
Blank lines:   260

-Wayne

Highlights of this release:

• Supported media formats:
  • MP3
  • FLAC
  • WAV
  • Ogg Vorbis
  • AVI
  • MPG
  • MP4
  • 3GP
• Additional language support: Afrikaans
• Automatically downloads HD version of the chosen video if available
• Proxy server support
• Login support – for downloading videos marked as private or age restricted

I’m keen to get feedback on what people would like to see in the next release.  You can report bugs or request new features here.  On that same site you can also vote for features that have already been requested.  The more votes a feature gets the more likely and quickly it is to be implemented.

-Wayne

Basically the given solution I thought best (at least for Windows platforms at this stage) is to use Windows’ built-in Data Protection API. This led to a follow-up question on Stack Overflow where the user “dF” pointed me to an example which uses Python’s ctypes library. This works really well and I’ve tidied up the example and added a couple of functions to make it more user friendly and play nicely as a library. You can view and download it below. Thanks again to “dF” and “Crusher Joe”.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# DPAPI access library
# This file uses code originally created by Crusher Joe:
# http://article.gmane.org/gmane.comp.python.ctypes/420
#
 
from ctypes import *
from ctypes.wintypes import DWORD
 
LocalFree = windll.kernel32.LocalFree
memcpy = cdll.msvcrt.memcpy
CryptProtectData = windll.crypt32.CryptProtectData
CryptUnprotectData = windll.crypt32.CryptUnprotectData
CRYPTPROTECT_UI_FORBIDDEN = 0x01
extraEntropy = "cl;ad13 \0al;323kjd #(adl;k$#ajsd"
 
class DATA_BLOB(Structure):
    _fields_ = [("cbData", DWORD), ("pbData", POINTER(c_char))]
 
def getData(blobOut):
    cbData = int(blobOut.cbData)
    pbData = blobOut.pbData
    buffer = c_buffer(cbData)
    memcpy(buffer, pbData, cbData)
    LocalFree(pbData);
    return buffer.raw
 
def Win32CryptProtectData(plainText, entropy):
    bufferIn = c_buffer(plainText, len(plainText))
    blobIn = DATA_BLOB(len(plainText), bufferIn)
    bufferEntropy = c_buffer(entropy, len(entropy))
    blobEntropy = DATA_BLOB(len(entropy), bufferEntropy)
    blobOut = DATA_BLOB()
 
    if CryptProtectData(byref(blobIn), u"python_data", byref(blobEntropy),
                       None, None, CRYPTPROTECT_UI_FORBIDDEN, byref(blobOut)):
        return getData(blobOut)
    else:
        return ""
 
def Win32CryptUnprotectData(cipherText, entropy):
    bufferIn = c_buffer(cipherText, len(cipherText))
    blobIn = DATA_BLOB(len(cipherText), bufferIn)
    bufferEntropy = c_buffer(entropy, len(entropy))
    blobEntropy = DATA_BLOB(len(entropy), bufferEntropy)
    blobOut = DATA_BLOB()
    if CryptUnprotectData(byref(blobIn), None, byref(blobEntropy), None, None,
                              CRYPTPROTECT_UI_FORBIDDEN, byref(blobOut)):
        return getData(blobOut)
    else:
        return ""
 
def cryptData(text):
    return Win32CryptProtectData(text, extraEntropy)
 
def decryptData(cipher_text):
    return Win32CryptUnprotectData(cipher_text, extraEntropy)

That mantra sounds deceptively simple and obvious, but remember it when you’re diagnosing a problem, programming or otherwise.

-Wayne