[nodejs] Observable Properties

Related... v8 just landed support for Object.observe()

-Rick

Is that the original non-optimized prototype or more optimized iteration of
it?

Implementation is still in progress. CLs that were landed introduce
the skeleton of the system but there are no notifications coming in
from the runtime yet.

I don't know what the actual plan is but I would expect that
implementation would degrade only performance of the observed objects
not the system as whole like prototype did (similar to Object.freeze).

Thanks for filling in the blanks—I accidentally deleted Jake's response, so
never saw until now

Rick

It was non-optimized. After reading your response, I spent couple of
hours on optimizing it. Here are the numbers:

Before optimization:

ak47-accessors: 7495ms
ak47-sub: 6963ms
ak47-subAll: 7785ms
ak47-pubsub: 6780ms

After optimization (v0.0.5)

ak47-accessors: 851ms
ak47-sub: 873ms
ak47-subAll: 1277ms
ak47-pubsub: 1868ms

And here how I measure it:
https://github.com/azer/ak47/blob/master/benchmarks/index.js

Just a heads up... The "thing" you're calling "accessors" are not
actually accessors.


Rick

You mean that benchmark doesn't contain any accessor or ak47 misses accessors?

Here is how I define a property with getters and setters using ak47:

function getter(d){ return Number(d); }
function setter(d){ return new Date(d); }

var date = a.property(new Date('1.1.1990'), getter, setter);

And that benchmark case uses default accessors unlike the example above.

A little misleading, because what you're illustrating is actually just "a
function". JavaScript accessors are created by defining get/set property
descriptors or named get/set accessors.

Rick

That's why ak47 exists! It introduces a new way of defining
properties. I don't think prefixing accessors as get/set is essential
to fill the definition of "accessor" in a dynamic language.

I never said anything about prefixing... Prefixing is also not really an
"accessor".

Actual accessors: https://gist.github.com/eda4398feb774be889b1

Rick

Thanks for the example. As I mentioned before, I prefer not using
JavaScript's getter and setter API. And by saying prefixing, I meant
creating two different functions to access a private variable like
getFoo and setFoo.

By the way, I would prefer using Ak47 over Object.observe for some
cases (if there isn't a significant performance issue). ak47 is not
only for object properties, it's also for observing variables;
age = ak47(birthdate, today, function(bd, td){
return parseInt( (td - bd) / 31536000000 );
});
22

It ensures all data structures are observable. And it's fairly simpler
than JavaScript's new accessor and observation APIs.

Here is a use case, assume we have a module like below:

// a.js

var foo = "hello",
bar = hello + " world";

module.exports = {
foo: foo,
bar: bar
};

// b.js
var a = require('./a');

a.foo = "What's up?"

console.log(a.foo); // what's up?
console.log(a.bar); // hello world

When we ignore using classes (or another way to create properties) in
CommonJS modules, we may have two copies of what we export from a
module. One is internal, the other one is external when a client
module overrides the property.

To solve this issue, I was creating properties like below:

var foo = (function(){

var value = undefined;

return function foo(newValue){
if(arguments.length){
value = newValue;
}

return value;
};

}());

And after using this pattern for long time, I came up to the the idea of ak47.