David Nolen just posted this to the MooTools Google group:

Well thought out blog post about why Prototype is preferred over jQuery. Not a mindless flame war piece, but a reasoned argument. Interestingly enough, MooTools actually _combines_ what he likes about Prototype and jQuery into one package! In particular, MooTools has a uniform design throughout, inheritance, a great CSS selector engine, good functional aspects, supports function chaining, and of course provies a couple of things that Prototype doesn’t properly have (multiple inheritance via Implements). I pointed some of these things out in a comment.

Good recommended reading.

David

Justin Palmer is shedding more light on Prototype updates.

This time around he covers events and DOM traversal:

Events

In days past bind was great at accepting additional arguments, however, bindAsEventListener didn’t get this love until now. We can pass those additional arguments to bindAsEventListener with ease:

var Clicker = Class.create();
Clicker.prototype = {
initialize: function(link) {
Event.observe(link, ‘click’, this.onClick.bindAsEventListener(this, ‘red’));
},onClick: function(event, color) {
Event.element(event).setStyle({color: color});
Event.stop(event);
}
}

new Clicker(‘cool’);

DOM made simple

We all hate the DOM, so how about some simpler methods to traverse it?

$(‘menu’).up();
$(‘menu’).down()
$(‘menu’).next()
$(‘menu’).previous()
$(‘menu’).down(2) // grab second arg
$(‘menu’).down(‘li’, 0)
$(‘sidebar’).descendants()
$(‘selected’).previousSiblings()
$(‘actions’).ancestors()
$(‘actions’).siblings()

And it looks like documentation is in the works:

On the documentation front: We have something in the works. We have the API about 80% documented and will have this up for public consumption as soon as we can. This will start off as very basic API docs, but we plan on putting a lot of effort in this as time goes by. On that note, you can send your thanks to Andrew Dupont considering he has worked very hard on the docs.

I always get a sinking feeling when Prototype starts to change. Sam (who maintains the project) is checking fixes for the next release today and Justin Palmer (encytemedia.com) is posting things that he’s seeing get checked in as it happens. On the one hand, the next version offers some nice improvements (thus far, there may be even more changes to come), but on the other, it’s stuff I’ve got to go dig into and incorporate into my work…

via ajaxian:
Justin Palmer has updated us with a bunch of recent Prototype updates including:

• Chainability: A bunch of methods now return their first arg so we can change together methods

  $('sidebar').addClassName('selected').show();
  $('sweet').observe('click', function(e) {
      console.log("%s was clicked", Event.element(e));
  }).setStyle({color: 'red'});

• Form and Form.Element methods mixed in to $ and $$
• Shorter syntax for Event Observing:
  $('element').observe('click', function(e) { alert(e); });
• Backwards Compatability: Element.toggle, Element.show, and Element.hide no longer take an arbitrary number of arguments
• Add serialization and observation support for input type=search
• Simulate non-GET/POST requests by POSTing with a _method parameter set to the actual verb
• Make Element.update() handle TABLE-related elements with the DOM API because of IE’s missing .innerHTML property on them
• and many more.

Now, what was I just saying?

via Ajaxian:

Cody Swann was working on a web application that was using the Dynamic Script Pattern, which Dojo has excellent support for, but Prototype didn’t.

Cody then extended Prototype to support ScriptSrcTransport similarly to how Dojo does it.

The code below support the Simple, Polling and JSONP and JSON Callbacks described in the Dojo book.

I just happened upon event:Selectors. It’s very similar to Behaviour.js (the author’s spelling, not mine) in most respects, though its much smaller (72 lines / ~2k) and has some nice added functionality using Prototype shortcuts (Behaviour is stand-alone and duplicates a lot of Prototype stuff and is, therefore, larger).

Basic usage:

var Rules = {
   '#icons a:mouseover': function(element) {
     var app = element.id;
     new Effect.BlindDown(app + '-content', {queue: 'end', duration: 0.2});
   },
 
   '#icons a:mouseout': function(element) {
     var app = element.id;
     new Effect.BlindUp(app + '-content', {queue: 'end', duration: 0.2});
   }
 }

Now, this alone is nice, but nothing exceptional. You could do the same thing with prototype thusly:

Event.observe(window,"load",function() {
  $$('#icons a').each(function(tag) {
    Event.observe(tag,'mouseover', function() {
      var app = tag.id;
      new Effect....
    });
  });
});

Ok, so it’s definitely longer to do without it, but not terribly so. But what really gets me excited is this:

 '#footer:loaded': function(element) {
    element.setStyle({backgroundColor: '#ccc'});
  }

This will apply the code to the element once it’s loaded. That’s just awesome. That’s just awesome times five. Wait, it gets better: it will also apply all your rules to your Ajax responses, too (if you want it to). This means when you bring in a chunk of html into the DOM you don’t have to set up all your events on it again.

It has a few other nice touches (you can, for instance, apply these events to more than one selector, for instance). Check it out.