Requires prototype.js version 1.6.0_rc0 or above.

Element.addMethods({
    lazyload: function (element, options) {
        /**
         What does it do?
         It delays loading of images in (long) pages. Images below the fold (far down in the
         page) won’t be loaded before the user scrolls down. This is exact opposite of image
         preloading. With long pages containing heavy image content end user result is the
         same. Page feels snappier. Browser is in ready state after loading visible images.
         No need to wait for n pictures to load.

         From Wikipedia:
         Lazy loading is a design pattern commonly used in computer programming to defer
         initialization of an object until the point at which it is needed. It can contribute
         to efficiency in the program’s operation if properly and appropriately used.

         Inspired by:

http://www.appelsiini.net/2007/9/lazy-load-images-jquery-plugin

         Requires:
         Prototype.js version 1.6.0_rc0 or later
         A page with lots of big images below the fold (optional)
         */

        function $restore() {
            // this function restores the original image source; called when above the fold
            if (true === $(element).hasAttribute('_src')) {
                $(element).writeAttribute({
                    src: $(element).readAttribute('_src')
                });
            }
        }

        function $scroll() {
            // this function returns the amount the page is scrolled vertically
            var scroll_y = self.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop;
            return parseInt(scroll_y);
        }

        function $height() {
            // this function returns the height of the viewport
            var window_height = window.innerHeight || document.documentElement.clientHeight;
            return parseInt(window_height);
        }
        var element = $(element);
        var options = Object.extend({
            threshold: 0,
            placeholder: '/images/grey.gif',
            event: 'scroll',
            frequency: 0.1
        }, options || {});

        var offset = $(element).cumulativeOffset()[1];
        var activate_on = (offset - options.threshold) - $height();

        var old_source = $(element).readAttribute('src');
        var new_source = options.placeholder;

        $(element).writeAttribute({
            src: new_source
        }).writeAttribute({
            '_src': old_source
        });

        if ('scroll' === options.event) {
            new PeriodicalExecuter(function ($executor) {
                if (activate_on & lt; = $scroll()) {
                    $restore();
                    $executor.stop();
                }
            }, options.frequency);
        }
        else {
            $(element).observe(options.event, function (event) {
                $restore();
                $(element).stopObserving();
            });
        }

        return $(element);
    }
});

document.observe('contentloaded', function () {
    $$('img').invoke('lazyload');
});

function matchColumns()
{
	var columns = $A($$('div.column'));
	var column_height = 0;
	var max_height = 0;
	columns.each(function(column)
	{
		column_height = column.getHeight();
		max_height = ( column_height > max_height ) ? column_height : max_height;
	});

	columns.each(function(column)
	{
		column.setStyle({
			height: (max_height + 10) + 'px'
		});
	});
}

Event.observe(window, 'load', matchColumns);

As always, this script requires prototype, and will work better if you have a DOMReady function instead of window.load.

Normal FAQs jump from the list of questions to the answer; with a simple bit of Javascript the page will smoothly scroll to the answer, and then–as a bonus–the answer will flash slightly.

Event.observe(window, 'load', function()
{
   $$('a[href^=#]:not([href=#])').each(function(element)
   {
      element.observe('click', function(event)
      {
         new Effect.ScrollTo(this.hash.substr(1),
         {
            offset: -12
         });

         if ( this.hash.substr(1) !== 'top' )
         {
            if ( Prototype.Browser.IE )
            {
               $(this.hash.substr(1)).setStyle({
                  backgroundColor: '#fff'
               });
            }

            Effect.Pulsate(this.hash.substr(1),
            {
               from: 0.5,
               pulses: 5
            });
         }

         Event.stop(event);
      }.bindAsEventListener(element));
   });
});

This script requires script.aculo.us

So here it is, the regular expression I have written for tradeswomen.biz:
search.match(/^(?:an?\s)?([A-Za-z\s]+)?\s(?:(?:in|from|near|around|
close to|working in|based in)\s)([A-Za-z0-9\s]+)(?:[.,;]?)$/);

Who wants to write document.getElementById("searchbox"); when you can write $('searchbox');And Ajax; how could it be easier to make an Ajax request than new Ajax.Request()Exactly, it couldn’t.

I’ve used it in a giant database-driven application we’re developing, and it has helped to trim hours of work down to mere minutes.

UPDATE: My new favourite thing!