These people are easily separable in two distinct groups. Those with prior programming experience and those without. I have made that same distinction in this blogpost.

No prior experience
If you have no prior experience in programming it is very important to realize that programming has a steep learning curve. The basic principles (variable assignment, conditionals and loops) are often easy to understand but getting to know the ideas behind solutions to everyday problems often takes a lot of time. Don’t worry, if you persist there will come a moment of enlightenment, this moment is bliss.

I strongly suggest that you don’t start out badgering on your own. A good start is the How to Think Like a Computer Scientist book which is freely available on the internet.

Another good start is the Higher Computing For Everyone website made by Carl Herold. It is focused more on the C language but it gets you down on the fundamentals in a good way.

Prior experience
If you have prior programming experience then the first step is to get to know Python’s type system, OO system and it’s stdlib. Also, keep in mind that in Python indenting is part of the syntax.

After you have gotten those out of the way it is time to start working on some features your previous language might not know, or might call/implement differently.

Take a look at list comprehensions, generators and how to create your own modules.

This is off course flying through Python at lightspeed. I strongly suggest you read the whole Python tutorial which is fully geared towards programmers with previous experience so you can learn all the intricacies.

Good luck!

You might also know I maintain the website for bpython. A more hidden fact might be that I like my statistics. I have decided to share those statistics about bpython with you as to give some insight on how much you might expect from a small open source project.

These statistics only reflect the traffic being directed towards the server where the bpython domain runs on (and, coincidentally, the bpaste domain). bpython is also available in many package managers (debian, ubuntu, freebsd, gentoo, to name a few). Those repositories do not cause a request to be served by the server.

Let me start with a big number, over the time bpython has been hosted by me it has been downloaded in excess of 25 000 times. I started hosting the website in june 2009 so that equates to a little over 2 500 downloads per month, or 80 downloads per day. This number is the only number I can confirm as I do have very little insight in installations being done through package managers (popcon offers little relief). However, I need to be honest, these numbers do not include recurrent downloads people do for upgrading their package. They do count the installations done through PyPi (easy_install, pip) as those just look up the package on our server.

We currently have a little over 4 500 pastes on bpaste in the six months that has been online. Over the past nine months we have had over 70 000 visitors on our website who transferred a total of 100 GB. Most of the traffic due to Bob’s screencast.

I am extremely pleased with these numbers, I just wished I could have a bit more insight in our current installation base. I don’t know how many people currently have bpython installed, or how many removed it again.

A fun thing to share with you people might be this graphic, depicting what a featuring on Reddit’s programming front page will do for your visitor count.

However, with bpython 0.9.6 there is a solution. We don’t build official windows packages just yet, but for the adventurous I have written down a guide in this blog post on how to get bpython.gtk_ to run on a windows machine. As of 0.9.6 the GTK part of bpython is still in its early days, its baby steps.

There is currently no support for hotkeys, there is no really fancy interface. However, it does have a nice icon, it has a beautiful dropdown box for the autocompletion and it supports your theme of preference. In the feature all the minor points will be resolved and more features added as development progresses.

Anyway, lets get down to the nitty-gritty.

To install bpython on a windows machine you need an installation of python + gtk, I could copy the page I followed to do this but I will not do that. I will just link you, if you follow this page you can then come back here.

You’ll also need to install pygments from their website.

After you have installed a full version of gtk, gobject etc. the best way to proceed is to install a minor alteration of the bpython 0.9.6 version. I assume you already have setuptools installed on your windows box (for the pygments install) so you can just download the linked file and do a setup.py install.

After this all you need to do is make a shortcut to the file created by setuptools (the usual place is C:\PythonXX\Scripts\bpython-gtk.exe) somewhere where you find it handy.

Expect bugs, problems and strange stuff happening in the window (including lots of noise in the cmd-window). Report anything that seems to be a veritable bug at our issue tracker.

Good luck (and a screenshot):

For this project I contribute code, I created, maintain and host their website and write the documentation.

For the 0.9.6 release a lot of bpython has changed and a lot has been added. I am writing this post as a preview to the now upcoming release of bpython 0.9.6. Let’s go over some of the more notable changes one by one.

Completion
Previous versions of bpython have always showed the __magic__ and _convention functions in front of the ‘real’ methods and attributes. In the new release you will find that methods/attributes starting with a _ are filtered out unless you explicitly type a _. This has been a much requested feature and is gladly provided for now.

Andreas was kind enough to add backwards cycling through the completion list by adding a shift-tab shortcut.

Dedentation
When you are in an indented block bpython will now automatically dedent after a few empty lines (default is 2, but this is configurable) so you don’t need to explicitly hit backspace any more.

PEP-8
I have checked the source code with pep8.py and fixed all non-conformations so bpython should now be fully conform PEP-8.

Themes
There is now a (very minimal) section on user-themes on the bpython website. If you have any others, please email them to me or give us a general heads up through the mailing list/IRC.

GTK
Andreas has been working on a GTK version of bpython for a while now and we feel confident enough to release it together with 0.9.6 so people can start to use it. bpython will feature a bpython-gtk to run bpython in a nice GTK window.

And more
A lot of bugs have been fixed, some other minor features have been added. Most notably this will be a very big release. Over 50 commits, more time between the releases then previous releases and a huge set of features (GTK, man!).

What are we waiting for with the release? There are a few thing we need to sort out before the release (how do we package bpython and bpython-gtk separately if we need to at all, etc) but a release will follow soon.

Furthermore I have some statistics for you.

bpython was downloaded over 1100 times the last month. We get over 650 unique visitors a day and our screencast is being watched 2000 times a month.

At the time of this writing #python features 732 distinct nicknames being one of the larger channels on the Freenode network.

Anyway, #python is a ‘special’ channel. There is a specific set of rules which make the channel a maintainable and live-able place.Anyone who joins the channel is at first confronted with:

-!- Topic for #python: NO LOL | http://pound-python.org/ | It's too early to use Python 3.x | Pasting > 3 lines? Pastebin: http://paste.pocoo.org/ | Tutorial: http://docs.python.org/tut/ | FAQ: http://effbot.org/pyfaq/ | New Programmer? Read http://tinyurl.com/thinkcspy

The important part to distill from this is:

NO LOL. This means no ‘lolspeak’, things like 1337, lol, rofl and such are often unnecessary noise. #python tries to keep the signal-to-noise ratio as low as possible. While thinking of a place where 700 people mumble senseless abbreviations all that springs to mind is a government. And nobody likes his government.

After that the rules are generally easy to understand. pound-python.org is a website which contains a certain subset of answers to often-asked questions on the #python channel. It is maintained through a bazaar repository on launchpad and hosted by me. It includes a part which I originally wrote for python-commandments.org on the how and why it is too early to use Python 3.x.

If you paste more then 3 lines of code it quickly floods the channel. If you do want to paste more then 3 lines of code, use a pastebin like the Pocoo one, bpaste or dpaste.

The tutorials in the topic are good, most people in the channel agree on them being good, as opposed to some of the other tutorials/books which might be of lesser perceived value to an interested person.

Now that we have all the ‘official’ nonsense out of the way, let me tell you more about the channel.

#python has a loyal regular pool of about 10-25 persons. Some work at Apple, some work at Google, some have no job. All of them might be interested in your problems though not all (or any) of them might be in at the time you ask.

We have a peculiar way of answering questions. More often then not you might get a counter-question on the how and why you are solving a certain problem. Do not feel offended if you get such a counter-question. The person on the other end just wants to know if you are going to use the right tool for the job. The best analogy I heard to this is that you might as well be asking how to drive a nail in to a wall with a coffee mug. We want to tell you that it is easier to use the hammer and want to verify you are not using a teapot.

This way of answering questions helps people. It helps people more then just giving the answer and being done with it. It also fits perfectly in the Python philosophy of not repeating done work. Most ‘hard’ problems have been solved before, and have been solved in a good way. For networking, Twisted is a prime example. For database wrappers SQLAlchemy is a prime example. It is for a reason these two are often mentioned on #python.

All in all, #python might seem like a hostile place, you have great idea and immediately you are being told to “Use Twisted” or that you shouldn’t be doing what you are doing at all (type checking, for instance). This is not meant as a “not wanting to help”-mentality. It is just a different kind of helping mentality. One that I like more.

Oh, and taking into account the intended audience for this weblog (and some statistics from my mighty server logs) I did not bother checking the Internet Explorer-family browsers just yet.

That’s why (amongst other things) I show graphs to my traffic, hits and server load prominently on my blog pages.

Other people might also know I have an unhealthy appetite for the stone age chatting protocol IRC. I currently reside in 36 channels on 5 different networks.

I decided to combine the two and start logging and graphing the usage. For the graphing I use pisg, which you can get by installing it from the repositories with:

aptitude install pisg

In this example you should already have irssi and apache running. I configured irssi with the following commands:

/set autolog on
/set autolog_path ~/irclogs/$tag/$0/%Y/%m/%e.txt

This makes irssi log all channels in the following format: network/channel/month/day.txt

I then created a pisg config:

<channel="#ubuntu-offtopic">
Logfile = "/home/simon/irclogs/freenode/#ubuntu-offtopic/**/**/*"
Format = "irssi"
Maintainer = "ikanobori"
OutputFile = "/home/simon/www_data/www.ikanobori.jp/ircstats/ubuntu-offtopic.html"
Network = "Freenode"
</channel>

I then added a cronjob with crontab -e:

1 * * * * /usr/bin/pisg -co /home/simon/irclogs/stats.cfg

Which makes pisg run every hour.

See the results of this specific pisg config here.

Oh, you also need to move the graphics file from the /usr/share/pisg/gfx directory to the directory where you are outputting your HTML so the graphs have their nice colors.

The first post in this blog will be about the tools I use for the projects web application end. It took me a lot of fiddling on my Virtual Private Server which has a limited amount of memory to make it so all my different tools work without having to restart apache every half an hour because of it chewing up all memory and not being able to handle request anymore.

First the tools we use:

• Apache 2, webserver
• SQLite, database
• Django, for the edb and our main website
• Zine, for our weblog
• Trac, for our bugtracker
• Sphinx, for the creation of our documentation

I’ll skip the part about sphinx, it only creates static html and there is nothing fancy about that. It is however great software and you should really give it a try. It is what Python uses for their own documentation.

I use a WSGI implementation called mod_wsgi to have the Python applications be server by Apache. It took me a lot of time to have it work so that it does not take up that much memory.

First of all, don’t use the embedded mode of mod_wsgi if you have little memory to spare. My VPS which runs all of Brutal Penetration’s web services only has 256 MB. If you use the embedded mode every worker process Apache spawns will have the full application you are serving contained within it. This makes consecutive requests (which are handled by the same worker process) really fast and costless but if you (like I do) have a lot of different applications on the same server this also takes a lot of worker processes which each range from 50-80MB in our case.

Use WSGI with the daemon mode. Our configuration concerning the edb which runs on django is, concerning the mod_wsgi part, like this:

WSGIDaemonProcess edb.bp threads=2 display-name=%{GROUP}
WSGIProcessGroup edb.bp

WSGIScriptAlias / /home/brutalpenetration/edb/edb.wsgi

This makes WSGI only spawn 1 process with 2 threads to serve requests. Apache workers only take up little space and direct their requests to these mod_wsgi processes. This saves a considerable amount of memory. I do this for all Python applications and for now I can say this about memory usage:

• Trac takes up 94 MB for a process.
• edb (Django) takes up 75 MB for a process.
• Zine takes up 87 MB for a process.

With all of those having a considerable amount of shared memory they actually use a little less. Now for some apache benchmark results, all tests run with ab -n 1000 -c 10 host:

Trac

Time taken for tests:   69.635 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      5830000 bytes
HTML transferred:       5486000 bytes
Requests per second:    14.36 [#/sec] (mean)
Time per request:       696.348 [ms] (mean)
Time per request:       69.635 [ms] (mean, across all concurrent requests)
Transfer rate:          81.76 [Kbytes/sec] received

edb (Django)

Concurrency Level:      10
Time taken for tests:   1.588 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      1836956 bytes
HTML transferred:       1684000 bytes
Requests per second:    629.89 [#/sec] (mean)
Time per request:       15.876 [ms] (mean)
Time per request:       1.588 [ms] (mean, across all concurrent requests)
Transfer rate:          1129.96 [Kbytes/sec] received

Weblog (Zine)

Concurrency Level:      10
Time taken for tests:   49.679 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      1835002 bytes
HTML transferred:       1691000 bytes
Requests per second:    20.13 [#/sec] (mean)
Time per request:       496.788 [ms] (mean)
Time per request:       49.679 [ms] (mean, across all concurrent requests)
Transfer rate:          36.07 [Kbytes/sec] received

And for comparison, a site serving only static content:

Documentation

Concurrency Level:      10
Time taken for tests:   0.239 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      274274 bytes
HTML transferred:       38038 bytes
Requests per second:    4177.32 [#/sec] (mean)
Time per request:       2.394 [ms] (mean)
Time per request:       0.239 [ms] (mean, across all concurrent requests)
Transfer rate:          1118.88 [Kbytes/sec] received

This pretty much concludes my blog post, I have one final tip, don’t use MySQL unless you have to. My mysqld used up 109 MB of memory which pushed everything into swap. I now use sqlite for django and zine and it works perfectly.

I have a text file containing numbers, a random amount of numbers per line and the numbers are of random size. Can you quickly give me a sum of all numbers? The file has to be read from stdin.

You can find the example file I used here.

I made a solution in Python, using generator comprehensions. However, a battle ensued in the comments to create the quickest version of this program and after a few comments about 30% was shaven off the time my Python program took. Then things took a turn, comments started dripping in of other languages. Haskell, PHP, Ruby and C amongst others were submitted.

Thus I have decided to create a little posting about this specific problem. Firstly I have compiled and run all the different versions and languages on my hardware and timed then. I ran every tool 10 times and averaged the result which resulted in this graph:

Source codes are here, however, if you think you can do any better than this please submit a link to a pastebin in the comments with some explanation and I’ll update this post and graph. I’d like for funky languages to be included as well, as long as I can compile it on my Debian server!

Results (scroll down for credits and source code for each language, think you can do better or have other languages? comment!):

• PHP: 2.53 s
• x86 asm: 0.04 s
• Ruby 1.9.1: 3.59 s
• C: 0.04 s
• Python: 2.18 s
• Haskell: 0.05 s
• gawk: 1.61 s
• Perl: 4.74 s
• Vala: 2.01 s

I also ran the fastest three on a large input file. Haskell fails, giving the wrong number.

• C: 2.91 s
• x86 asm: 4.39 s

Clearly, C and Haskell reign supreme even knowing more about the processor instructions then RayNbow’s x86 solution. Python is fastest at the interpreted languages. I ran the Ruby sample on Ruby 1.8 as well which took 20ish seconds, Ruby is surely stepping up it’s game, speedwise, still lacking a bit behind PHP though.

C (luite) (gcc -O2):

#include <stdio.h>
#include <stdint.h>

int main(int argc, char** argv) {
  uint64_t sum=0;
  char buf[8192];
  int cur=0;
  int i,j;
  while((i=fread(buf,1,8192,stdin))>0) {
    for(j=0;j<i;j++) {
      char c = buf[j];
      if(c >= '0' && c <= '9') {
  cur = (cur*10)+c-48;
      } else {
  sum+=cur;
  cur=0;
      }
    }
  }
  sum+=cur;
  printf("total: %llu\n", sum); /* what is the correct format type for uint64_t? */
}

Haskell (Don Stewart):

{-# LANGUAGE BangPatterns #-}
--
-- The Computer Language Shootout
-- http://shootout.alioth.debian.org/
--
-- A lazy bytestring solution
--

import qualified Data.ByteString.Char8 as S

main = do
    putStr "Grand total "
    print . go 0 =<< S.getContents
  where
    go !n !s = case S.readInt s of -- lazily reads current line
                    Nothing     -> n
                    Just (k,t)  -> go (n+k) (S.tail t)


{-

-- Important: turn on optimizations:

$ ghc -O2 --make A.hs             
[1 of 1] Compiling Main             ( A.hs, A.o )
Linking A ...

$ cksum input_list_vs_gen.txt 
2913999841 17293232 input_list_vs_gen.txt

$ du -hs input_list_vs_gen.txt 
17M input_list_vs_gen.txt

$ time ./A < input_list_vs_gen.txt 
Grand total 17677692470
./A < input_list_vs_gen.txt  0.19s user 0.06s system 98% cpu 0.254 total

-}

PHP (John Piasetzki):

while($line = fgets(STDIN))
  $s += array_sum(explode(' ',$line));
echo $s;

Python (Pythoneer):

#!/usr/bin/env/python
import sys
from itertools import imap

print sum(sum(imap(int, line.split())) for line in sys.stdin)

Ruby (Thomas Hurst):

#!/usr/bin/env ruby
total = 0
STDIN.each_line {|line| line.split(" ").each {|x| total += x.to_i } }
puts "Grand total: #{total}"

x86 asm (James Block):

; for NASM, a 386 or better, and a 2.6-series Linux kernel
; it should run fine on a 64-bit system with appropriate flags for NASM
; assemble with nasm -f elf FILENAME.asm && ld FILENAME.o -o OUTPUTFILENAME
; run as ./OUTPUTFILENAME < INPUT_NUMBERS.txt
; expect weirdness with nonconforming input. this is pure assembly, you know
; each input number should be at most 32 bits, and the sum at most 64 bits

buffersize equ (1<<16)	;use 64kB chunks; can be set to any value
			;64kB is fastest on this old Willamette P4

section .data
	message: db "Grand total:"
	printbuffer: times 23 db 0x20
	dw 0x0A
	msglen equ $ - message

section .text
	global _start

_start:
	;we want to read a bunch of numbers from STDIN
	;we'll do this by allocating memory with mmap()
	;and then reading stdin with read()
	;
	;mmap signature:
	; void* mmap(void* start, size_t length, int prot, int flags,
	;	int fd, off_t offset);
	; (defined in <sys/mman.h>)
	;
	;arguments:
	; start - pass 0, usually ignored
	; length - pass $BIGNUM to allocate a $BIGNUM chunk
	; prot - pass PROT_READ | PROT_WRITE (0x01|0x02)
	; flags - pass MAP_PRIVATE (0x02) | MAP_ANONYMOUS (0x20)
	; fd - pass anything (-1)
	; offset - pass anything
	;
	; linux calling convention: 6-arg syscalls use the stack
	;   push arguments in REVERSE order
	;
	; system call number goes in eax:
	;  exit:	1
	;  read:	3
	;  write:	4
	;  mmap:	90
	;  munmap:	91

	mov esi, buffersize	;store buffer size in esi

	push dword 0	;offset
	push dword -1	;fd
	push dword 0x22	;flags - MAP_PRIVATE|MAP_ANONYMOUS
	push dword 0x03	;prot - PROT_READ|PROT_WRITE
	push dword esi	;allocation size
	push dword 0	;start
	mov eax, 90
	mov ebx, esp

	int 80h
	add esp, (4*6)	;clean up the refuse from calling mmap()

	;now eax holds the start address for our memory! yay!
	;let's put it in ebp instead, since ebp isn't good for much else
	mov ebp, eax

	;now let's read() in the data from stdin
	;read() signature:
	; ssize_t read(int fd, void* buf, size_t count)
	;3-arg syscalls pass arguments in registers, so
	;this one's much easier than mmap():

	mov ecx, eax
	mov ebx, 0
	mov eax, 3
	mov edx, esi
	int 80h

	;accumulate in the traditional pairing edx:eax
	;let ecx index our position in the memory block

	;read digits into ebx, accumulate into numbers in edi
	; then sum edi to the main accumulator, edx:eax
	; anything but a digit ends a number
	; zero byte ends all counting

	xor edx, edx
	xor eax, eax
	xor ecx, ecx
	dec ecx

readdigit:
	xor edi, edi
readdigit_lp:
	xor ebx, ebx
	inc ecx
	cmp ecx, esi
	je readmore
gotmore:mov bl, byte [ebp+ecx]
	test bl, bl
	jz finished_summing		;exit on zero byte

	sub bl, 48
	js next_number
	cmp bl, 9
	ja next_number	;if this is not a digit, skip it and sum

	shl edi, 1
	lea edi, [edi*4 + edi]
	add edi, ebx
	jmp readdigit_lp

next_number:
	add eax, edi
	jnc readdigit
	inc edx
	jmp readdigit

readmore:
	mov esp, eax
	mov eax, 3
	xor ebx, ebx
	mov ecx, ebp
	xchg edx, esi
	int 80h

	;if we didn't fill the whole buffer, stick a zero byte after the
	; bit we *did* read, to ensure proper termination of the loop

	cmp eax, edx
	je readcleanup
	mov byte [ebp+eax+1], 00
readcleanup:
	xor ecx, ecx
	xchg edx, esi
	mov eax, esp
	jmp gotmore

finished_summing:
	;edx:eax contains the 64-bit sum
	;now we have to print it
	;the following is an EXTREMELY ugly printf(%llu) substitute

	mov ecx, (printbuffer+22)
	mov ebp, 10
	mov esp, 429496729

printlp64:
	;if we can bail on this horrid 64-bit print loop
	; and use a much saner 32-bit version,
	; then, damn it, EXIT NOW
	test edx, edx
	jz printlp32

	;algorithm (64-bit divmod): let W = 2**32, Z = X + Y*W
	; (i.e., X is eax and Y is edx)
	; then let M = 10 (modulus) and define
	; X divmod M = (x_D, x_M)   (the definition of divmod:
	; Y divmod M = (y_D, y_M)   (quotient, remainder))
	; W divmod M = (W_D, W_M)
	;
	; let u = x_M + y_M * W_M and calculate
	; u divmod M = (u_D, u_M)
	;
	; then the following is true:
	; Z divmod M = (y_D * W + x_D + y_M*W_D + u_D, u_M)
	;
	; the following pile of junk implements the above
	;  (and allows for overflow in a couple places)

	mov edi, eax
	mov eax, edx
	xor edx, edx
	div ebp
	lea ebx, [edx*3]
	shl ebx, 1
	mov esi, eax
	mov eax, edx
	mul esp
	;edx:eax has y_M*W_D, ebx has y_M*W_M, edi has x, esi has y_D
	add esi, edx
	xor edx, edx
	xchg eax, edi
	div ebp
	;eax has x_D, edx has x_M, esi has y_D, edi has y_M*W_D
	add ebx, edx	;ebx has u
	add edi, eax
	xor edx, edx
	mov eax, ebx
	div ebp
	;eax has u_D, edx has u_M
	add dl, 0x30
	mov byte [ecx], dl
	dec ecx
	mov edx, esi
	add eax, edi
	jnc printlp64
	inc edx
	jmp printlp64

printlp32:
	div ebp
	add dl, 0x30
	mov byte [ecx], dl
	dec ecx
	xor edx, edx
	test eax, eax
	jnz printlp32

EXIT:
	mov eax, 4
	mov ebx, 1
	mov ecx, message
	mov edx, msglen
	int 80h

	mov eax, 1
	mov ebx, 0
	int 80h

Perl (Michael Pyne):

#!/usr/bin/env perl

use strict;

my $sum = 0;
while(<STDIN>) {
my @nums = split(' ');
foreach my $num (@nums) { $sum += $num; }
}

print "$sum\n";

Gawk (Eric Wong):

gawk 'END { printf "%d\n", n } { for (i=NF;i>0;--i) n += $i}'

Vala (snuxoll):

using GLib;

namespace snuxoll {
    class StdinReader : Object {

        public StdinReader () {

        }

        public bool eof() {
            return stdin.eof();
        }

        public string? read_line() {
            var line = new StringBuilder();
            var buffer = new char[1024];
            while ( ( !line.str.has_suffix ("\n") ) || this.eof() ) {
                string chunk = stdin.gets(buffer);
                if (chunk != null) {
                    line.append(chunk);
                } else {
                  return null;
                }
            }
            return line.str;
        }

    }
}

// start other file

using GLib;
using snuxoll;

class SumApplication : Object {

    private uint64 total { get; set; }

    public SumApplication() {
        this.total = 0;
    }

    public void run() {
        var reader = new StdinReader();
        while ( !stdin.eof() ) {
            var line = reader.read_line();
            if ( line != null ) {
              var nums = line.strip().split(" ");
              foreach(string num in nums) {
                    this.total += num.to_int();
                }
            }
        }
        stdout.printf("Grand Total: %llu\n", total);
    }

    static int main(string[] args) {
        var app = new SumApplication();
        app.run();
        return 0;
    }

}

I will start by describing my problem. The problem concerns a large tree which is foldable, by a large tree I am talking about about 200 main nodes with each of them ≈ 5 subnodes with each subnode an arbitrary number of pages or other subnodes.

We load the sublevels using AJAX. This works fine. The tree at first is generated from XML using XSL and the outputted HTML looks like this:

<ul class="vline">
  <li class="sep">&nbsp;</li>
  <li id="C697EDFA-1517-64D9-CCE728FA69AABB13" class="open">
    <div class="toggle">&nbsp;</div>
    <div class="label">
      <a href="#">Loret Ipsum</a>
    </div>
    <div class="active"><a href="#">nl</a></div>
    <ul class="vline">
      <li class="sep">&nbsp;</li>
      <li class="closed" id="C697EE29-1517-64D9-CC87AC418D9DF2E4">
        <div class="toggle">&nbsp;</div>
        <div class="label">
          <a href="#">Dolor sit amet</a>
        </div>
      </li>
      <li class="sep">&nbsp;</li>
      <li class="closed" id="C697EE29-1517-64D9-CC87AC418D9DF2E4">
        <div class="toggle">&nbsp;</div>
        <div class="label">
          <a href="#">Nunc est amet</a>
        </div>
      </li>
      <li class="sep">&nbsp;</li>
    </ul>
  </li>
  <li class="sep">&nbsp;</li>
</ul>

This generates a nice list. I then use selectors to make certain parts droppable (‘li a’), (‘.sep’) and certain parts draggable (‘li’). This works fine with the default jQuery draggable/droppable. However, the default draggable/droppable is painstakingly slow. It looks like it recalculates all droptargets’ positions the moment you start dragging. This causes a 1 to 2 second delay on the MacBook Pro I am developing on, I don’t even dare to think about the slower cpu’s used by clients and visitors.

The drop targets need to be recalculated because a user can fold/unfold nodes to their liking. If you do not update the drop targets then a folded tree will give funny results because the targets below the folded node have changed position.

So I ventured out to start recalculating drop targets when I fold or unfold a node. This causes a delay in the folding/unfolding in which I can show a nice AJAXish loading image which looks good to the user and obfuscates the amount of calculations being done in the background.

What I have tried to get this behaviour:

• First I started fiddling with a plugin called jquery.event.drop and rebinding the droppable event when a node folds/unfolds. This is to no avail.
• Second I updated my jQuery to 1.3 to use live events, this did not help but did break a lot of other existing jQuery code.

I know the plugin jquery.event.drop has a setup() method which uses it’s built in method locate() to calculate all drop targets. However I just can not seem to find out how to call this setup() function again.

Is this just impossible in jQuery and should I build it from scratch or is there some nifty way of doing this which I am totally overlooking?

Also, a little excerpt from the javascript I am using right now:

function create_drop_targets() {
  $('li a')
    .bind('dropstart', function(event) {
    })
    .bind('drop', function(event) {
    })
    .bind('dropend', function(event) {
    });
}