Here’s the language construct you need to familiarize yourself with to do encapsulation:

var myNamespace = (function(){ // assign the return value of an anonymous function to a var in the global space
function myNamespace(){
// Initialize
}
var hiddenStuff = “my secret”; // anything you define here will be hidden from the global scope.
return myNamespace;
})();

As for polymorphic inheritance, it is actually easy to inherit from an object, and override a parent method.

Parent = function() {
// bunch of properties
}
Parent.someMethod = function () {
// some behavior to override
}

var parentObj = new Parent();
var childObj = Object.create(parentObj);
childObj.someMethod = function () {
// new behavior for child
}

Of course, you can also do all this within the child object’s constructor, and then just do:

var childObj = new ChildObj();

When you call childObj.someMethod(); you’ll get the child version, not the parent’s prototype version.

Javascript is certainly a different way of working, but once you wrap your brain around prototypical inheritance, you’ll see that:

1) Javascript can mimic class-based inheritance models, complete with encapsulation and polymorphic inheritance.

2) Prototypical inheritance is actually less verbose and more expressive than class-based inheritance, and…

3) Class-based inheritance cannot easily mimic prototypical inheritance.

In other words – Javascript has BETTER OO than C++ and Java.

If you want to criticize Javascript, there are plenty of valid attacks you can make – for example, Javascript lacks fast matrix manipulation capabilities, because it lacks support for predictable array element lengths (array elements with strong types). It also only supports one number type, (IEEE float), and that number type sucks for doing even basic floating point math.

Until these REAL problems are fixed, we’re never going to see, for example, a high-performance 3D game engine written in Javascript running in the browser. (Although there are people doing 2 1/2 D game engines similar to the original Doom engine even with these limitations).

I find your position untenable. If we all attach our own meaning and definitions to words, what’s the point of having a dictionary and how do we communicate efficiently and effectively with one another?

I’m not familiar with Small Talk. Are you saying it doesn’t support encapsulation and dynamic binding?

Re your last question, if it was sincere and not rhetorical, a scripting language is a language used to control another piece of software, in the case of JavaScript, the software is the browser.

Peace

And I’m tired of people believing that OO means only one thing.

Is Smalltalk OO? Of course it is–but most implementations have no concept of private variables, instead relying on convention. There’s also instVarAt: and instVarAt:put: messages.

Is Self OO? Of course it is–it’s also a prototypal-inheritance language.

(And what’s a “scripting language”?)