1. Download blank.png,
2. Click change background in bottom left corner,
3. Click “From my computer”,
4. Upload file you just downloaded.

It’s not as good as original Google page, but it definitely more eye-friendly that their idea of it.

When you open new tab in most browsers you got plenty space wasted on automated pages like most frequently visited. Well, what if I visit some pages 3-4 times a month but I’d really like to have them quickly accessible. Bookmark toolbars times are gone… they stick on screen, they’re awful to manage (4 clicks to get to ONE “well categorized” bookmark???).

This single screen replaces 3-click deep bookmark tree.

Now how it’s done.

1. Get “New Tab Favorites”* Google Chrome Extension,
2. find it’s files and replace newtab.html with your own file.
3. Voila!

*) other new tab extensions will do as well but this one leaves address bar EMPTY so it’s faster to paste or search on new tab.

yes, it’s ugly as hell. Each input type is different size, padding, etc.Chrome on Windows it’s messy too but less noticeable because of Windows default inputs:

Come on Google! Get to work and do something about it, even IE8 looks better:

and you should really aim to Firefox 3.6 on Linux amazing looks:

To Firefox team: amazing work thou it might be because of Ubuntu system theme design. Thank you. Now give me speed and flexibility of Chrome (like moving tabs between windows without reseting state of its content) and I’ll switch back. I promise ;P

…But I like my html to be cleared of all unnecessary mess which in many cases end up like this:

<a href="...">link1</a> <a href="...">link2</a>

generates awful:

link1link2

In addition if you like having your templates indented it leaves awful things like:

<div>
                                Test text testt
                             </div>

Here’s my “smart” version of strip_spaces_between_tags which can be used with overrided spaceless template tag:

def strip_multiple_spaces_between_tags(value):
    """Returns the given HTML with multiple spaces between tags removed."""
    def tagcheck(obj, prefix='', sufix=''):
        tag = obj.group(1).lower()
        if tag[0] == '/':
            tag = tag[1:]
        if tag != 'pre':
            return '%s<%s>%s' % (prefix, ''.join(obj.groups('')), sufix)
        return obj.group(0)
    def tagprecheck(obj):
        return tagcheck(obj, sufix=' ')
    def tagpostcheck(obj):
        return tagcheck(obj, prefix=' ')

    value = force_unicode(value)
    value = re.sub(r'<(/?[\w]+)([^>]*)>\s{2,}', tagprecheck, value);
    value = re.sub(r'\s{2,}<(/?[\w]+)([^>]*)>', tagpostcheck, value)
    value = re.sub(r'>\s{2,}<', '> <', value)
    return value
strip_multiple_spaces_between_tags = allow_lazy(strip_multiple_spaces_between_tags, unicode)

This does few things:

• it removes all multiple spaces between tags,
• it removes all multiple spaces at from “<tag> HERE text HERE </tag>” on all tags except pre.

If you find it useful or you have fix/extension to it (any other tag I should think of?) please feel free to comment.

Well. I did. After searching, more searching, waiting for few months and then searching again I found none working out of box.

So I wrote one, you can find it on bitbucket: django_openid_provider.

Download, add it to your installed apps and urlpatterns, create openid for your django.contrib.auth user and it’s ready to use!

Next in line was little fresher ZSI. I say little because its last version was dated November 2007. It was better than SOAPpy, it correctly formated and encoded outgoing message but when response was received with same data type that was sent ZSI couldn’t handle it.

After about 6 hours of debugging and forcing ZSI to work with that data type I thought “So well supported (library-wise) language like Python cannot have this particular technology supported so bad” and I started digging again. I stumbled upon hundreds of opinions like “SOAP sucks! so why you want to implement it? use REST or anything but not SOAP”. Well, if it were up to me I would do it RESTfull but it wasn’t! I was provided with access to third party application, they weren’t able to give me anything else so I have to live with it – they won’t add another API just because I use language that has bad support for protocol of their choice and many other popular languages (like PHP or Ruby) support it just like that.

And then I found it. On StackOverflow if found guy with same problem as mine. Answer he got was “use suds – it really works”. I’ve given it a try and it works. Include, 2 lines of code and? works like charm, uses WSDL defined types, enumeration, service inspection (with type requirements) by simple “print object”, unicode nad so on…

So if you really need to use SOAP in Python then I recommend use suds.

Let’s take closer look on both MPMs philosophy. Both somehow derived from prefork which provide good performance without need to use only “thread safe” libs and code (like worker does).

itk works very similar to prefork. When request arives itk checks to which vhost it is directected and performs: fork & setgid & setuid and when forked process sends response it’s killed. Well, where’s preforks speed boost which comes from serving several (hundreds, thousands) requests on preforked apache process? Well, itk ignores that need and just forks instantly :/

peruser has better design but it requires more precise configuration. peruser creates process pool same way prefork does but on that stage it actually performs setgid & setuid it also leaves few processes as multiplexers which direct all incoming request to process which match uid & gid with vhost configuration.

Here you have links where you can read about itk & peruser configuration. Now lets do some testing.

For testing I was using siege, default WordPress on mysql (mod_php and php-cgi) and simple django site (mod_python). In each case siege was run like this: siege -c 20 -b -t 1m URL

itk, mod_python (django):
Transactions:                    566 hits
Availability:                  99.65 %
Elapsed time:                  63.20 secs
Data transferred:               0.61 MB
Response time:                  1.87 secs
Transaction rate:               8.96 trans/sec
Throughput:                     0.01 MB/sec
Concurrency:                   16.74
Successful transactions:         565
Failed transactions:               2
Longest transaction:           28.07
Shortest transaction:           0.25
peruser, mod_python (django):
Transactions:                  17422 hits
Availability:                 100.00 %
Elapsed time:                  59.55 secs
Data transferred:              16.13 MB
Response time:                  0.07 secs
Transaction rate:             292.56 trans/sec
Throughput:                     0.27 MB/sec
Concurrency:                   19.97
Successful transactions:       17422
Failed transactions:               0
Longest transaction:            5.10
Shortest transaction:           0.01

itk, php5cgi (wordpress):
Transactions:                    757 hits
Availability:                  99.87 %
Elapsed time:                  61.29 secs
Data transferred:              11.13 MB
Response time:                  1.53 secs
Transaction rate:              12.35 trans/sec
Throughput:                     0.18 MB/sec
Concurrency:                   18.91
Successful transactions:         757
Failed transactions:               1
Longest transaction:           29.51
Shortest transaction:           0.19
peruser, php5cgi (wordpress):
Transactions:                    762 hits
Availability:                 100.00 %
Elapsed time:                  61.12 secs
Data transferred:              11.24 MB
Response time:                  1.57 secs
Transaction rate:              12.47 trans/sec
Throughput:                     0.18 MB/sec
Concurrency:                   19.57
Successful transactions:         762
Failed transactions:               0
Longest transaction:           17.14
Shortest transaction:           0.19

itk, mod_php5 (wordpress):
Transactions:                    814 hits
Availability:                  99.88 %
Elapsed time:                  60.95 secs
Data transferred:              11.52 MB
Response time:                  1.31 secs
Transaction rate:              13.36 trans/sec
Throughput:                     0.19 MB/sec
Concurrency:                   17.54
Successful transactions:         814
Failed transactions:               1
Longest transaction:           22.11
Shortest transaction:           0.17
peruser, mod_php5 (wordpress):
Transactions:                   1034 hits
Availability:                 100.00 %
Elapsed time:                  64.72 secs
Data transferred:              14.63 MB
Response time:                  1.21 secs
Transaction rate:              15.98 trans/sec
Throughput:                     0.23 MB/sec
Concurrency:                   19.34
Successful transactions:        1034
Failed transactions:               0
Longest transaction:           24.50
Shortest transaction:           0.15

Conclusion? It’s faster (well, not in case of CGI but CGI each time execs php binary anyway), in some cases much faster but even 25% on mod_php5 is boost worth consideration. Nevertheless test it yourself for your particular case because from practical applications I know there’s no ideal setup that will work for “everything”.