Sure you do, it’s just that Java makes it extremely difficult, by working actively against the developer.

JavaScript sees these attempts because it *allows you to make them*.

jQuery embraces a functional style which is closer to home in a language like JS which has its roots in Scheme.

Java/C++ style can be done but is a force fit.

I agree with this statement, and to take it out of context for a second (OOP or not) is this not the direction we are taking? Allow the *competent* developer knowledgeably jump from one implementation to another without a glance to the documentation. As well as making it increasingly more efficient to develop these applications that keep food on the table.

It would seem as though we are moving in this direction albeit ’slowly but surely’. I can hardly wait for the day when open source unifies

Great post, thanks.

On the topic of OO JavaScript, have you looked at or heard of Ajile - http://ajile.iskitz.com/.

It’s a Namespacing library for JavaScript that extends the language with missing functionality without imposing new ways of writing code. Most OO developers already understand the power and convenience of namespacing, but it’s a concept that’s only now emerging as needed for JavaScript in this age of mashups and ajax mania.

Ajile’s namespacing and accompanying Import, ImportAs, Include, and Load directives (mimicked via functions) also support the OO Model View Controller (MVC) design pattern by automating the linkage and inclusion of JavaScript logic to HTML views. That allows developers to safely separate their server-side business logic from their front-end views, view manipulation, and client-to-server data transfer.

I’m interested to hear what you have to say about it and the concepts it introduces to the oh so flexible JavaScript language

http://remysharp.com/2007/04/12/jquerys-this-demystified/

The only thing I’d add is that, by convention, when creating a custom class, I use that to alias this:

var myObject = function() {
var that = this;
}

I then use that within callbacks and interior functions to reference the top-level object:

var myObject = function() {
var that = this;
this.foo = “foo!”;
var innerFunction = function() {
alert(that.foo);
}
this.publicMethod = function() {
innerFunction();
}
}

This convention, which helps obviate the need for Prototype-style Function.bind(), comes from Douglas Crockford.

That’s 3 widget sets, and I love widgets. Almost anything I do, I start with an existing widget, and extend it a bit to do all the things I need. Works great, and often I don’t even have to touch it, already does what I need entirely, even with the world-class, super-fussy UI designer I work with..

Prototype can use Ext too, but I have seen nothing in the prototype arena that can compare to the jquery plugin library. The Jquery plugin lib appears to me, to be growing exponentially. The Ajax community is really coming together around Jquery.

Scriptaculous does not even come close as far as I can tell…
Am I missing something?

a small piece that compares the two frameworks, with some nice links to follow..
…

for community support jquery/prototype wins

but for elegance Object orientation in javascript, and the overall design philosophy. Mootools is far more cleaner

at the end of the day, it is just depends on how your brain works, mootools inherit many to all prototype goodness.

for OO purist/software design freak like myself, mootools is additive and inspiring

That’s “Willison”.

Yes, exactly. Prototype (and jQuery, to a lesser extent) attempts to rewrite Javascript and turn it into something else. Javascript is not, fundamentally, a C-style language. It’s the ugly duckling of the Lisp/Scheme/Haskell crowd. Turning it into Ruby or Java is a misguided notion that short-circuits what Javascript is fundamentally all about.

Doug Crockford’s “Module Pattern” is just what Javascript gives you for free. Like most things in YUI, it’s just showing off effective use of the language, rather than showing off how the language can be transformed into something different.

It’s interesting that Javascript is the only language to suffer this sort of abuse on a regular basis. You don’t see Java frameworks that aim to make it more like Ruby, or C++ frameworks that emulate Ada. I think Javascript got a bad rap–guilt by association with flickering doodads in the 1990s, perhaps. For whatever reason, it seems that the software development crowd seems to be largely of the opinion that Javascript is too hard, badly designed, and not “really” OOP, but at least it can be transformed into a “real” language with the proper framework.

I wrote about this a few weeks ago in response to a post by Matt Snider:
http://foohack.com/?p=24