On 17.04.2010 0:30, Tom Van Cutsem wrote:
The static methods are to avoid "breaking the web" by
injecting even
non-enumerable names into every object -- including the global
object --
via Object.prototype. Such injection can easily break
user-controlled
"object detection" done on colliding names.
I appreciate that. "Not breaking the web" seems to be the excuse
that everyone trots out when they introduce a kludge. I'm sure the
changes were necessary and I'll bow to my betters on this one.
I don't see the ES5 Object API as a kludge at all.
From a metaprogramming/reflection point-of-view, this API is very much
in line with the Mirror design principles outlined by Gilad Bracha and
Dave Ungar (see <http://bracha.org/mirrors.pdf>)
The paper makes the case why you don't want to define all 'meta-level'
operations on the objects themselves. This architecture was used
successfully in Self and in JDI (the Java Debugger Interface).
Yes, it is. As I wrote, stratification for "meta" and "app" levels was a
good reason in document mentioned at the beginning of this thread. But
indeed, Java's implementation of this question (with mirror reflections)
is just one of several. And this separation line can be smoothed. E.g.
getting value of dynamically formed property name -- is it a /meta/ or
/app/ operation? For example, Python treats it as meta:
getattr(bar, "foo")
In contrast, ES has for that purpose bracket notation property accessor,
which is also /meta/ operation from this viewpoint. That means it
supports introspection /embedded into the syntax/ without additional
long intermediate operations, which makes its usage very convenient.
Should ES remove bracket notation (or change its meaning)? Who said
that? Java?
String representation -- is it a /meta/ or /app/ operation? Python also
has special "str" function (callable class) which takes responsibility
for that (actually, calling internal __str__ method of an object).
But Java and ES treat it as object's method -- toString.
Getting /length/ of something -- is a meta or app operation? And so on,
and so forth.
It might take the sting out if there were a way to curry the
leading
|obj| parameter as |this| that was cheaper than
Object.defineProperty(Object.prototype, 'keys', {value:
function () {
return Object.keys(this); }});
Why isn't defineProperty an instance method? It seems strange that
it is a static method.
Imagine what Java would look like if all methods defined on
java.lang.Class were defined on java.lang.Object directly instead (and
would use 'this' instead of requiring an instance to be passed to
Method.invoke and Field.get). As you mentioned yourself: <quote>"One
of the things I always liked about JavaScript is that I didn't have to
remember a lot of things."</quote>
The more stuff that's defined on objects by default, the more I have
to remember not to define a method called 'defineProperty' in my
application. Defining them 'outside of' the objects means most
Javascript programmers don't need to bother with these methods at all.
/Introspection/:
"foo" in bar
foo["bar" + "baz"]
for /each/ ( ... in ...) {...}
/Self-modification/:
foo.bar = function () {};
delete foo;
/Execution of dynamically generated code/:
Function("alert(ba" + (x ? "r" : "z") + ")")();
var foo = (function () {
if (x) {
return function () {alert(1);}
} else {
return function () {alert(2);}
}
})()();
And so on.
How will it look in Java with its "Method.invoke" and "Field.get"? If it
will take 10 intermediate actions for that -- could we send to hell such
JavaScript then?
Keystrokes matter, but you have to take into account the cognitive
overhead of remembering all inherited method names from some global
object as well.
Neither keystrokes, nor "I should remember much" matter here. Any good
editor should support auto-complete and useful code snippets. This about
ideology of a language. But, yeah, it is debatable what should be
treated as /meta/ operation and should ES do it the way Java does --
with its long intermediate code.
But in general, the idea with mirrors is noble (and is used in some
other languages, even in PHP; sorry for mention it agai ;)). Although I
don't see a /huge/ advantage of this. In languages with dynamic mutable
objects, introspection methods can be treated as just a /basic
functionality/ of any object. And the /app/ level functionality -- is
already an addition (some kind of invariants) with distinguishes these
objects from others.
Dmitry.
_______________________________________________
es-discuss mailing list
[email protected]
https://mail.mozilla.org/listinfo/es-discuss