The . is not required but makes it compatible with more browsers.

That doesn’t sound very good, I want it to be compatible with all browsers…

I couldn’t find much on it, from what I did find I believe the reason it doesn’t work with all browsers is for security. If I had the domain er.com, and I set a cookie to the domain er.com (notice the missing .), the browser could match this with older.com or lesser.com. If the website at er.com set the cookie to er.com (without the first .), the web server on older.com or lesser.com can access this cookie…not good. Therefore, even if I remove the . from the domain, it still would match media.indirecthit.com and that domain wouldn’t be cookieless.Doesn’t solve my problem and isn’t compatible with most browsers.

The solution, is to split out your media server on a different domain such as indirecthitmedia.com. This is why when you visit some Google properties it loads media content from gstatic.com not media.google.com or google.com. And obviously you don’t set any cookies to this new media domain. You will now score a bit higher on Google Page Speed and YSlow. Congrats!

The first image below is in Opera, and the second is in Firefox. I wanted it to look like it does in Firefox.

The HTML for the above is:

1
2
3
4
5
6
7
8
9
10
11
12

<table width="550px" border="1">
	<tr>
		<td align="center">
			<table border="1" width="80%">
				<tr>
					<td>Apple Sauce</td>
					<td>Pecan Pumpkin Butter</td>
				</tr>
			</table>
		</td>
	</tr>
</table>

The problem is that the

<td align="center">

is inherited by the tables within that table for IE and Opera but not for Firefox. It’s an easy fix, just make the next <td> into <td align=”left”> to fix it. It’s nothing major, probably very well known…but the first time I’ve come across it.

Django comes with a caching middleware that caches any request made to the site that doesn’t have a POST or GET. You can set the cache to only cache pages for anonymous (using CACHE_MIDDLEWARE_ANONYMOUS_ONLY). The second piece of the puzzle is that the login view for Django sets a test cookie when a visitor first comes to the page, if this is not there, the login will fail.

What happens is:

1. Make a request to the login page without any GET or POST parameters.
2. Web server returns the cached page. (Note: this doesn’t set the cookie because no Python code has been run, the page returned is static)
3. The user enters in the login information and submits the information. This is sent to the server as a POST.
4. The server, because of the POST, now runs the login view. This fails because there was no cookie previously set, but it does set the cookie that should have been previously set.
5. The error message shown to the user is as if it was a failed attempt. If the user reenters the information, the login will now work as the cookie is now set.

Hopefully that makes some sense.

What is the solution? Unfortunately, the caching middleware doesn’t allow you to fine-grain what it caches, it’s an all or nothing. There are two solutions:

1. Always pass a GET param to the login page. By passing a GET param, the caching middleware will not return the cached page.
2. Turn off the caching middleware and instead use the more fine-grained per-view cache.

I’m trying the GET parameter. We’ll see how it works.

There is a Java specification currently in draft for REST, it’s called JSR 311. Now the problem with this is that it is still a draft.

There are currently a few implementations of JSR 311:

• Jersey – Part of Glassfish (SUN’s open source JEE server)
• Apache CXF – This was previously XFire, an implementation of SOAP for Java. It has also started to implement JSR 311. I think this implementation isn’t as fully featured as the other implementations.
• RESTeasy – JBoss’s implementation of JSR 311.

There are a few other options for REST and Java. One option that has been around for a while is called Restlet. The creator of Restlet is involved in the writing of JSR 311 but I don’t believe his project implements JSR 311. Update[11-Jun-08]: As commented below by Jerome Louvel and Stephan Koops there is an extension to Restlet to implement JSR 311, more information can be found on the Restlet Wiki.

Currently, I’m using Apache CXF for my project. But I’m hoping to move to Jersey or RESTeasy because they have a more complete implementation.

The problem with Jersey is that it doesn’t play nice with Hibernate and Maven. This is caused by Hibernate requiring cglib which requires ASM 1.5.3, while Jersey requires ASM 3. There are a few solutions described on the web, but they haven’t solved the problem for me. I’m hoping to work on this at some point, once I find a solution (if I do) then I’ll post it.

IETester was just released, this tool looks to be incredibly handy. Right now it’s in Alpha, but I’m still planning on using it. Previously I used Multiple IE, but I found that to be a little buggy and prone to not work at all at times. I’m planning on giving it a try sometime today, maybe it will solve at least some problems on testing with IE.

A little late, but Google released an API for loading common JS libraries (such as JQuery, Prototype, Mootools, etc.) from their network of CDNs. This will also increase the chances of someone having the common library cached, instead of having to download an individual copy of JQuery for each site they visit. It’s not a new idea, AOL has hosted the Dojo JS library on it’s CDN for the past few years (more details). Still, I’m glad to see it expand into other libraries. I will probably move StartupIndex.ca to load the JQuery library from Google.

You can pass it the excludes field to exclude certain fields from being compared. It does not compare AutoField or RelatedField’s.

1
2
3
4
5
6
7
8
9
10

from django.db.models import fields
def get_changes_between_models(model1, model2, excludes = []):
    changes = {}
    for field in model1._meta.fields:
        if not (isinstance(field, (fields.AutoField, fields.related.RelatedField)) 
                or field.name in excludes):
            if field.value_from_object(model1) != field.value_from_object(model2):
                changes[field.verbose_name] = (field.value_from_object(model1),
                                                   field.value_from_object(model2))
    return changes

Based off of code from Django Modelhistory.

The solution? Force the queryset to a list. For example:

1
2
3

queryset = Widget.objects.all()
wlist = list(queryset)
cache.set("allwidgets", wlist, 3600)

This does mean that you can’t use the cached list as a queryset, so you’ll have to cache it after all the filtering, ordering, etc. has been done.

The major differences between these are how they handle the syntax highlighting and the look. To help compare these I’ve taken screenshots of all the plugins highlighting a piece of code and written up a quick blurb about them.

iG:Syntax Hiliter

URL: http://blog.igeek.info/still-fresh/category/wp-plugins/igsyntax-hiliter/

Description:

iG:Syntax Hiliter uses GeSHi, a common code highlighter, and as such supports a good amount of languages. The code appears to be last updated in February of 2006 and uses version 1.0.7.6 of GeSHi which is about 14 versions behind the current release of GeSHi.Most of the changes to GeSHi are adding of more language definitions and not a lot of feature changes. GeSHi generates the code on the server side.

Code is defined in the Wordpress editor by the language name surrounded by square brackets, e.g.: [php]…[/php].

Some of the more notable features of iG:Syntax Hiliter are:

• It can highlight code in comments
• Can show plain text version of the code
• Has an option for fancy line numbers

SyntaxHighlighter Plus

URL: http://wordpress.org/extend/plugins/syntaxhighlighter-plus/

Description:

This is an enhanced version of another plugin called SyntaxHighlighter. It supports a smaller subset of languages then some other plugins but is capable of handling the major ones (PHP, Python, Java, JavaScript, etc). To handle the syntax highlighting it uses SyntaxHighlighter a JavaScript library to highlight code. The library argues that by making it JavaScript there are no dependencies on the server. I don’t know if this is a major issue with most Wordpress installs, and does add dependencies on the client side that they must have JavaScript.

You define the code by using one of the following tags:

• [css]…[/css]
• [code lang="css"]...[/code]
• [source lang="css"]…[/source]
• And some other variations…>

WP-Syntax

URL: http://wordpress.org/extend/plugins/wp-syntax/

Description:

WP-Syntax is another plugin that uses the GeSHi library to handle syntax highlighting. The GeSHi is 1.0.7.20 which is the latest version and supports a very large set of languages. The formating used by WP-Syntax can be defined through CSS (Cascading Style Sheets) or by defining the GeSHi initialization settings to match the design of your blog. It supposedly does not conflict with any other plugins by pulling out the code early and then placing it back in after other plugins have finished processing the blog text.

The code to be highlighted is specified by surrounding it with <pre lang=”php”>…</pre>

WP-CODEBOX

URL: http://wordpress.org/extend/plugins/wp-codebox/

Description:

WP-CODEBOX is a relatively new plugin that uses GeSHi to handle the highlighting. It comes with an administration interface that you can edit the defaults.

You specify the code by using: <pre lang=”php”>…</pre>

Some of the major features are:

• You can specify a file containing the code that a reader can download.
• If no file is specified it will have a “View in Plain Text” option.
• Can collapse a block of code.

Conclusion

As of the writing of this, I’m going to try out WP-Syntax. I’m a big fan of the simplicity and believe it will fit in with the overall design of my blog. I played around with all 4 plugins a little bit, but I need to try some real world examples before I come to a final decision. I’ll update this post or write a new one with what I think after trying out WP-Syntax for a few posts.

On Well.ca we had previously implemented this feature using Levenshtein, this measures the number of permutations to get from one string to another. The problem with this is that we had the search term “Obus” being corrected to “Burt’s”, not exactly the most accurate system. As a result, I’ve been working with using Pspell/Aspell to handle the “Did you mean”. Aspell is a very popular spell checking software, you can find it used in almost any OS application requiring spell checking. PHP interfaces with Aspell through Pspell.

One of the requirements we have, is that we want Pspell/Aspell to use a custom dictionary. Being an Ecommerce site, we want the dictionary to consist of brands, product names, categories, and product subtitles. A limitation of Pspell is that it does not allow you to use just a personal dictionary, therefore, I went through the process of creating a custom language dictionary for Pspell/Aspell to use. I have described all the steps below, from the initial install to the actual checking.

Installing:

Note: These are the following steps I used to install Aspell/Pspell on my Macbook Pro running the latest version of OS X. They should work fine for Linux/Unix systems, for Windows there are other resources on the web for installing these tools.

1. Install Aspell – Install Aspell using your package manager (I use MacPorts) or from the Aspell website.
2. Compile PHP w/ PSpell support
   1. First check to see if your PHP install already is built w/ Pspell (look at the output of php_info() for the configure flag –with-pspell)
   2. (If you are using MacPorts look at the bullet below) If not, compile PHP with all the options you want including “–with-pspell={prefix}”. Where prefix is the location of your lib and include containing Pspell.
      • If you are using MacPorts, you can add the flag to the Portfile. On my computer, the Portfile was located at “/opt/local/var/macports/sources/ rsync.macports.org/release/ports /www/php4/Portfile”. Open that file and add “–with-pspell=${prefix}” to configure.args. You can then uninstall PHP4 and reinstall it, it should now use the modified Portfile to compile PHP.
   3. Restart Apache, and check your php_info() for the proper flags.
3. You should now be capable of using pspell in PHP.

Creating a Custom Language Dictionary

Note: If you don’t need a custom language dictionary, you can skip straight to the creating “Did you mean” section.

1. Download the aspell-lang package:
   [code]cvs -z3 -d:pserver:anonymous@cvs.savannah.gnu.org:/sources/aspell co aspell-lang[/code]
   The remainder of the steps are now based off of the README file
2. Head into the aspell-lang directory. Aspell-lang comes with a command for creating the files used to create a new custom dictionary. The command to create these files is:
   [code]./pre {lang_name} {char_set}[/code]
   • lang_name must follow the ISO language standards. At the simplest, two alphabetical characters.
   • char_set aspell can use a variety of character sets. See the README for a list of them. For English, I used iso-8859-1
   • The command I used was: ./pre we iso-8859-1
3. You should now have a directory called the language name selected. CD into that directory.
4. At this point, you can edit the info file or leave it at the default. It is fairly self explanatory.
5. You can now create the wordlist in the file {lang_name}.wl. The format is one word per line.
6. By default, aspell does not allow any non-alphabetical characters in words. To allow other characters you need to modify {lang_name}.dat
   • The line you need to modify starts with special, you might need to uncomment it.
   • The format of the special line is: special {char} {start}{middle}{end}. char is the character to be included. start, middle, end tells Aspell where the character is allowed. ‘*’ means the character is allowed, ‘-’ means the character is not.
   • An example special attribute is ‘ -*-, the character is ‘, and it is not allowed as the first or last character of the word but is allowed in the middle of the word.
7. When the wordlist is finalized, you need to run the following commands:

   ./proc
   ./configure
   make
   make install

8. Ignoring any problems, you should now have a custom dictionary installed.

Creating “Did you mean”

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

//Split the search string by spaces
$keywords_single = explode(' ', $keywords_string);
//Get the number of words they are searching by
$sizeof_keywords_single = sizeof($keywords_single);
$pspell_config = pspell_config_create("we");
$pspell_link = pspell_new_config($pspell_config);
$keywords_single_replacement = array(); //Create the replacement array
for($i = 0; $i < $sizeof_keywords_single; $i++) { //Loop through the words
	//Check if the word is correctly spelt
	if (!pspell_check($pspell_link, $keywords_single[$i])) {
		$keywords_misspell = true;
		//Get the suggestions from Pspell
		$suggestions = pspell_suggest($pspell_link, $keywords_single[$i]);
		//Take the first result (Pspell sorts the result)
		$keywords_single_replacement[$i] = $suggestions[0];
	} else {
		//Set the replacement word back to the original word
		$keywords_single_replacement[$i] = $keywords_single[$i];
	}
}
/*
 * The following code replaces the words with the corrected words above.
 */
if (!isset($keywords_phrase) && isset($keywords_misspell)) {
	$keywords_replacement = stripslashes($_GET['keyword']);
	for ($i = 0; $i < $sizeof_keywords_single; $i++) {
		$keywords_replacement = preg_replace(
					sprintf('#(?!<.*?)(%s)(?![^<>]*?>)#i',
					preg_quote($keywords_single[$i])),
					$keywords_single_replacement[$i],
					$keywords_replacement);
	}
}
//You can now print the Did You Mean $keywords_replacement...
?>

Resources

• Pspell Manual – http://www.php.net/manual/en/ref.pspell.php
• Aspell Website – http://aspell.net/

Even with that name it does work with Mac OSX, there is even a FAQ entry for running IEs 4 Linux on OSX. Here is the process I went through to install IEs 4 Linux on my machine:

Requirements:

• MacPorts – http://www.macports.org (You can also use Fink)
• X11 SDK and X11 User installed (These can be found on your install DVD)

Steps:

First, I installed the required packages through MacPorts for Wine:
[cc lang="bash"]sudo port install cabextract wget fontforge freetype[/cc]
Note: If you have a problem with installing these packages, you might need to run the command “clean” with port. This removes all the temporary files created. E.g. “sudo port clean –all freetype”

After installing these packages, I then installed Wine:
[cc lang="bash"]sudo port install wine[/cc]

All that’s left is running the install script for IEs 4 Linux. Then you can run the X11 application installed with X11User and call the command ie, ie55 or ie5 in xterm.

Now that is the way that it was supposed to work, in reality I came across a few problems:

You have an Apple X11 installation already:

[cc lang="bash"]
You have an Apple X11 installation already.
MacPorts will not overwrite it.

If you really want to use XFree86 instead,
please move it aside first :
[/cc]
This was caused by having X11 SDK installed but not X11 User installed. X11 User is located in /System/Installation/Packages/X11User.pkg. After installing, make sure to run the “clean -all” command.

Wine is not found:

This error message shows up when xterm does not have a properly set up PATH. To correct this, read this page on Options for MacPorts’ shell and X11 Environment.

Good luck!