When I discovered that **Node.js was built using the V8 JavaScript engine**, I thought: 

&gt; Great, web scraping will be easier as the page 
  will be rendered like in the browser, with a 
  &quot;native&quot; DOM supporting XPath and any AJAX calls on 
  the page executed.

1. Why doesn&#39;t it have a native DOM when it uses the same JavaScript engine as Chrome?
2. Why doesn&#39;t it have a mode to run JavaScript in retrieved pages?
3. What am I not understanding about JavaScript engines vs the engine in a web browser?

Many thanks!

Why doesn&#39;t Node.js have a native DOM?

What are the options for running (possibly malicious) user-submitted scripts in node.js, securely?  I.e. in an environment that prevents code from accessing sensitive data and APIs?

`vm.runInNewContext(userScript, {})` is a tempting starting point... but it seems like there are [known issues][1] there.

The [sandbox module][2] looks interesting, but uses `runInNewContext()` as well so I&#39;m a bit leery of it.


  [1]: https://github.com/joyent/node/issues/1469
  [2]: https://github.com/gf3/sandbox

How to run user-submitted scripts securely in a node.js sandbox?

**Edit: since chrome has updated the browser - this question is some what redundant as they have fixed an internal bug which means this problem no longer occurs.**

I have an animation of a circle anchored to the center of the canvas.

The larger the circle becomes the less stable the motion is. But not only that, for me at least it is significantly worse in Chrome to Firefox.

The math is done in this function:

    function update(deltaTime){
        var centerX = canvas.width/2;
        var centerY = canvas.height/2;
            i.currentAngle = (i.currentAngle || 0) + (deltaTime/1000 * i.rotationSpeed);
        
        if(i.currentAngle&gt;2*Math.PI){
            i.currentAngle-=2*Math.PI;
        }
    		i.x = centerX + (i.radius*i.factor) * Math.cos(i.currentAngle);
    		i.y = centerY + (i.radius*i.factor) * Math.sin(i.currentAngle);  
    }

This is the code in working example:

**http://jsfiddle.net/96QDK/**

Chrome outputs:

![][1]


Firefox Outputs:

![enter image description here][2]


  [1]: http://i.imgur.com/rpsTi4N.gif
  [2]: http://i.imgur.com/baArE7E.gif


Firefox seems to be closest to what I am aiming for yet Chrome is just wacky. 

Why do I get such different results? I should mention I&#39;ve asked a few people what they see, and everyone is seeing different amounts of inaccuracy.

Different results using the same maths in different browsers

In [nodejs][1], the only way to execute external commands is via sys.exec(cmd). I&#39;d like to call an external command and give it data via stdin. In nodejs there does yet not appear to be a way to open a command and then push data to it (only to exec and receive its standard+error outputs), so it appears the only way I&#39;ve got to do this right now is via a single string command such as:

    var dangerStr = &quot;bad stuff here&quot;;
    sys.exec(&quot;echo &#39;&quot; + dangerStr + &quot;&#39; | somecommand&quot;);

Most answers to questions like this have focused on either regex which doesn&#39;t work for me in nodejs (which uses Google&#39;s V8 Javascript engine) or native features from other languages like Python.

I&#39;d like to escape dangerStr so that it&#39;s safe to compose an exec string like the one above. If it helps, dangerStr will contain JSON data.

  [1]: http://nodejs.org/

How do I escape a string for a shell command in node?

What is the difference/connection between these objects in V8? Does a context &quot;belong&quot; to an Isolate or vice versa?

I know that a single Isolate may only be accessed by one thread at a time (and that&#39;s what v8::Locker is for I guess?).

I&#39;ve looked through the docs but I can&#39;t seem to get a grasp on these concepts - any help is appreciated!

What exactly is the difference between v8::Isolate and v8::Context?

Maybe not because the call is slow, but rather the lookup is; I&#39;m not sure, but here is an example:

    var foo = {};
    foo.fn = function() {};
    
    var bar = {};
    bar.fn = function() {};
    
    console.time(&#39;t&#39;);
    
    for (var i = 0; i &lt; 100000000; i++) {
    	foo.fn();
    }
    
    console.timeEnd(&#39;t&#39;);

Tested on win8.1

 - firefox 35.01: **~240ms**
 - chrome 40.0.2214.93 (V8 3.30.33.15): **~760ms**
 - msie 11: **34 sec**
 - nodejs 0.10.21 (V8 3.14.5.9): **~100ms**
 - iojs 1.0.4 (V8 4.1.0.12): **~760ms**

Now here is the interesting part, if i change `bar.fn` to `bar.somethingelse`:

 - chrome 40.0.2214.93 (V8 3.30.33.15): **~100ms**
 - nodejs 0.10.21 (V8 3.14.5.9): **~100ms**
 - iojs 1.0.4 (V8 4.1.0.12): **~100ms**

Something went wrong in v8 lately? What causes this?

slow function call in V8 when using the same key for the functions in different objects

I&#39;m having some trouble to understand how Node.js acts based on the parameter `max-old-space-size`.

In my case, for example, I&#39;m running two `t2.small` AWS instances (2GB of RAM).

Not sure why, but I did set `max-old-space-size=4096` (4GB). What does node do in this case? Could this configuration lead to a possible memory allocation failure?

How do I determine the correct value of `max-old-space-size` based on the server resources?

My application is constantly growing the memory usage and I&#39;m trying to understand everything about node internals.

How do I determine the correct &quot;max-old-space-size&quot; for node.js?

**Scenario**: Consider the following is the part of code from a node web app.

    app.get(&#39;/users/:id?&#39;, function(req, res, next){
        var id = req.params.id;
        if (id) {
            // do something
        } else {
            next(); //or return next();
        }
    });

**Issue**: I am checking which one to go with just `next()` or `return next()`. Above sample code works exactly the same for both &amp; did not show any difference in execution. 

**Question**: Can some one put light on this, when to use `next()` and when to use `return next()` and some important difference?

When to use next() and return next() in Node.js

I am reading the slides [Breaking the Javascript Speed Limit with V8](https://v8-io12.appspot.com/#16), and there is an example like the code below. I cannot figure out why `&lt;=` is slower than `&lt;` in this case, can anybody explain that? Any comments are appreciated.

Slow:

    this.isPrimeDivisible = function(candidate) {
        for (var i = 1; i &lt;= this.prime_count; ++i) {
            if (candidate % this.primes[i] == 0) return true;
        }
        return false;
    } 

(Hint: primes is an array of length prime_count)

Faster:

    this.isPrimeDivisible = function(candidate) {
        for (var i = 1; i &lt; this.prime_count; ++i) {
            if (candidate % this.primes[i] == 0) return true;
        }
        return false;
    } 

**[More Info]** the speed improvement is significant, in my local environment test, the results are as follows: 

    V8 version 7.3.0 (candidate) 

Slow:

     time d8 prime.js
     287107
     12.71 user 
     0.05 system 
     0:12.84 elapsed 

Faster:

    time d8 prime.js
    287107
    1.82 user 
    0.01 system 
    0:01.84 elapsed

Why is &lt;= slower than &lt; using this code snippet in V8?

In Bluebird&#39;s [`util.js` file](https://github.com/petkaantonov/bluebird/blob/7454401269cfa47e5b001354388c062509103de7/src/util.js#L180), it has the following function:

    function toFastProperties(obj) {
        /*jshint -W027*/
        function f() {}
        f.prototype = obj;
        ASSERT(&quot;%HasFastProperties&quot;, true, obj);
        return f;
        eval(obj);
    }

For some reason, there&#39;s a statement after the return function, which I&#39;m not sure why it&#39;s there.

As well, it seems that it is deliberate, as the author had silenced the JSHint warning about this:

&gt; Unreachable &#39;eval&#39; after &#39;return&#39;. (W027)

What exactly does this function do? Does `util.toFastProperties` really make an object&#39;s properties &quot;faster&quot;?

I&#39;ve searched through Bluebird&#39;s GitHub repository for any comments in the source code or an explanation in their list of issues, but I couldn&#39;t find any.

How does Bluebird&#39;s util.toFastProperties function make an object&#39;s properties &quot;fast&quot;?

A new stable release of Node.js (0.12) has landed recently with an upgraded Google&#39;s v8 JavaScript engine, *v3.28.73*.

## What ECMAScript 6 features are currently present in Node.js, without using the `--harmony` flag?

I have checked several sites claiming to list the ES 6 features but all of them seem out of date - most prominently, [this table](http://kangax.github.io/compat-table/es6/#node) (**Update:** *now updated with current Node.js status as of 0.12*), because several of the features are listed as requiring the `--harmony` flag while I found some of them being enabled by default (Maps, Sets, Symbols, to name a few). **Update**: [Node specific tables][1] have since been made available

Also, trying to google this information purely for the v8 engine gives too up-to-date information - current v8 release is *4.2.\**, which is quite ahead of what Node.js uses.

My hopes are that this question (and its answers) will become a comprehensive summary on what ES 6 features are now available to Node.js developers.

## ES 6 features enabled in Node.js 0.12 I currently know of:

- Maps, Sets / WeakMaps, WeakSets
- Symbols
- Object.observe
- Promises
- Number
  - .isInteger
  - .isSafeInteger
  - .isNaN
  - .EPSILON
  - .MIN_SAFE_INTEGER
  - .MAX_SAFE_INTEGER
- Math
  - .clz32
  - .imul
  - .sign
  - .log10
  - .log2
  - .log1p
  - .expm1
  - .cosh
  - .sinh
  - .tanh
  - .acosh
  - .asinh
  - .atanh
  - .trunc
  - .fround
  - .cbrt
  - .hypot


  [1]: http://node.green/

ECMAScript 6 features available in Node.js 0.12

From the official documentation ([source][1]):

&gt; **process.memoryUsage()**
&gt; 
&gt; Returns an object describing the memory usage of the Node process
&gt; measured in bytes.
&gt; 
&gt;     var util = require(&#39;util&#39;);
&gt;     
&gt;     console.log(util.inspect(process.memoryUsage()));
&gt; 
&gt; This will generate:
&gt; 
&gt;     { rss: 4935680, heapTotal: 1826816, heapUsed: 650472 }
&gt; 
&gt; heapTotal and heapUsed refer to V8&#39;s memory usage.

Exactly what do **rss**, **heapTotal**, and **heapUsed** stand for? 

It might seem like a trivial question, but I&#39;ve been looking and I could not find a clear answer so far.


  [1]: http://nodejs.org/api/process.html#process_process_memoryusage

What do the return values of node.js process.memoryUsage() stand for?

How is V8 installed along with NodeJs? What version is my current V8 engine?

How to check which version of v8 is installed with my NodeJS?

I am looking into Javascript programming without a browser. I want to run scripts from the Linux or Mac OS X command line, much like we run any other scripting language (ruby, php, perl, python...)

    $ javascript my_javascript_code.js

I looked into spider monkey (Mozilla) and v8 (Google), but both of these appear to be embedded.  

Is anyone using Javascript as a scripting language to be executed from the command line?

If anyone is curious why I am looking into this, I&#39;ve been poking around [node.js](http://www.nodejs.org).  The performance of node.js makes me wonder if javascript may be a viable scripting language for processing large data.


Executing JavaScript without a browser?

I want to run a Javascript console on top of V8. How do I do this?


Running V8 Javascript Engine Standalone

I&#39;ve just discovered the ECMAScript 7 feature `a**b` as an alternative for `Math.pow(a,b)` ([MDN Reference][1]) and came across a discussion in [that post][2], in which they apparently behave differently. I&#39;ve tested it in Chrome 55 and can confirm that the results differ.

`Math.pow(99,99)` returns `3.697296376497263e+197`

whereas

`99**99` returns `3.697296376497268e+197`

So logging the difference `Math.pow(99,99) - 99**99` results in `-5.311379928167671e+182`.

So far it could be said, that it&#39;s simply another implementation, but wrapping it in a function behaves different again:

    function diff(x) {
      return Math.pow(x,x) - x**x;
    }

calling `diff(99)` returns `0`.

Why is that happening?

As [xszaboj][3] pointed out, this can be narrowed down to this problem:

    var x = 99;
    x**x - 99**99; // Returns -5.311379928167671e+182

  [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation_(**)
  [2]: http://www.2ality.com/2016/02/exponentiation-operator.html#comment-2946471782
  [3]: https://stackoverflow.com/users/3454771/xszaboj


Why is Math.pow() (sometimes) not equal to ** in JavaScript?

Regardless of functional differences, does using the new keywords &#39;let&#39; and &#39;const&#39; have any generalized or specific impact on performance relative to &#39;var&#39;?

After running the program:

    function timeit(f, N, S) {
        var start, timeTaken;
        var stats = {min: 1e50, max: 0, N: 0, sum: 0, sqsum: 0};
        var i;
        for (i = 0; i &lt; S; ++i) {
            start = Date.now();
            f(N);
            timeTaken = Date.now() - start;
    
            stats.min = Math.min(timeTaken, stats.min);
            stats.max = Math.max(timeTaken, stats.max);
            stats.sum += timeTaken;
            stats.sqsum += timeTaken * timeTaken;
            stats.N++
        }
    
        var mean = stats.sum / stats.N;
        var sqmean = stats.sqsum / stats.N;
    
        return {min: stats.min, max: stats.max, mean: mean, spread: Math.sqrt(sqmean - mean * mean)};
    }
    
    var variable1 = 10;
    var variable2 = 10;
    var variable3 = 10;
    var variable4 = 10;
    var variable5 = 10;
    var variable6 = 10;
    var variable7 = 10;
    var variable8 = 10;
    var variable9 = 10;
    var variable10 = 10;
    
    function varAccess(N) {
        var i, sum;
        for (i = 0; i &lt; N; ++i) {
            sum += variable1;
            sum += variable2;
            sum += variable3;
            sum += variable4;
            sum += variable5;
            sum += variable6;
            sum += variable7;
            sum += variable8;
            sum += variable9;
            sum += variable10;
        }
        return sum;
    }
    
    const constant1 = 10;
    const constant2 = 10;
    const constant3 = 10;
    const constant4 = 10;
    const constant5 = 10;
    const constant6 = 10;
    const constant7 = 10;
    const constant8 = 10;
    const constant9 = 10;
    const constant10 = 10;
    
    function constAccess(N) {
        var i, sum;
        for (i = 0; i &lt; N; ++i) {
            sum += constant1;
            sum += constant2;
            sum += constant3;
            sum += constant4;
            sum += constant5;
            sum += constant6;
            sum += constant7;
            sum += constant8;
            sum += constant9;
            sum += constant10;
        }
        return sum;
    }
    
    
    function control(N) {
        var i, sum;
        for (i = 0; i &lt; N; ++i) {
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
            sum += 10;
        }
        return sum;
    }
    
    console.log(&quot;ctl = &quot; + JSON.stringify(timeit(control, 10000000, 50)));
    console.log(&quot;con = &quot; + JSON.stringify(timeit(constAccess, 10000000, 50)));
    console.log(&quot;var = &quot; + JSON.stringify(timeit(varAccess, 10000000, 50)));

 
.. My results were the following:

    ctl = {&quot;min&quot;:101,&quot;max&quot;:117,&quot;mean&quot;:108.34,&quot;spread&quot;:4.145407097016924}
    con = {&quot;min&quot;:107,&quot;max&quot;:572,&quot;mean&quot;:435.7,&quot;spread&quot;:169.4998820058587}
    var = {&quot;min&quot;:103,&quot;max&quot;:608,&quot;mean&quot;:439.82,&quot;spread&quot;:176.44417700791374}

However discussion as noted here seems to indicate a real potential for performance differences under certain scenarios: https://esdiscuss.org/topic/performance-concern-with-let-const



v8 JavaScript performance implications of const, let, and var?

How can I get the most accurate time stamp in Node.js?

ps My version of Node.js is 0.8.X and the [node-microtime extension][1] doesn&#39;t work for me (crash on install) 


  [1]: https://github.com/wadey/node-microtime

How to get a microtime in Node.js?

Performance associated with Arrays and Objects in JavaScript (especially Google V8) would be very interesting to document.  I find no comprehensive article on this topic anywhere on the Internet.

I understand that some Objects use classes as their underlying data structure. If there are a lot of properties, it is sometimes treated as a hash table?

I also understand that Arrays are sometimes treated like C++ Arrays (i.e. fast random indexing, slow deletion and resizing).  And, other times, they are treated more like Objects (fast indexing, fast insertion/removal, more memory).  And, maybe sometimes they are stored as linked lists (i.e. slow random indexing, fast removal/insertion at the beginning/end)

**What is the precise performance of Array/Object retrievals and manipulations in JavaScript?** (specifically for Google V8)

More specifically, what it the performance impact of:

 - Adding a property to an Object
 - Removing a property from an Object
 - Indexing a property in an Object
 - Adding an item to an Array
 - Removing an item from an Array
 - Indexing an item in an Array
 - Calling Array.pop()
 - Calling Array.push()
 - Calling Array.shift()
 - Calling Array.unshift()
 - Calling Array.slice()

Any articles or links for more details would be appreciated, as well.  :)

**EDIT:** I am really wondering how JavaScript arrays and objects work under the hood.  Also, in what *context* does the V8 engine &quot;know&quot; to &quot;switch-over&quot; to another data structure?

For example, suppose I create an array with...

    var arr = [];
    arr[10000000] = 20;
    arr.push(21);

What&#39;s really going on here?

Or... what about this...???

    var arr = [];
    //Add lots of items
    for(var i = 0; i &lt; 1000000; i++)
        arr[i] = Math.random();
    //Now I use it like a queue...
    for(var i = 0; i &lt; arr.length; i++)
    {
        var item = arr[i].shift();
        //Do something with item...
    }

For conventional arrays, the performance would be terrible; whereas, if a LinkedList was used... not so bad.

What is the performance of Objects/Arrays in JavaScript? (specifically for Google V8)

Executing this snippet in the Chrome console:

&lt;!-- begin snippet: js hide: false console: true --&gt;

&lt;!-- language: lang-js --&gt;

    function foo() {
        return typeof null === &#39;undefined&#39;;
    }
    for(var i = 0; i &lt; 1000; i++) console.log(foo());

&lt;!-- end snippet --&gt;

should print 1000 times `false`, but on some machines will print `false` for a number of iterations, then `true` for the rest. 

[![enter image description here][1]][1]

Why is this happening? Is it just a bug? 


  [1]: http://i.stack.imgur.com/FuFKT.jpg

Why does the value of typeof null change inside a loop?

I am trying to log a long array so I can copy it quickly in my terminal. However, if I try and log the array it looks like:

    [&#39;item&#39;,
     &#39;item&#39;,
      &gt;&gt;more items&lt;&lt;&lt;
      ... 399 more items ]

How can I log the entire array so I can copy it really quickly? 

Dumping whole array: console.log and console.dir output &quot;... NUM more items]&quot;

I don&#39;t fully get what [Node.js][1] is all about. Maybe it&#39;s because I am mainly a web based business application developer. What is it and what is the use of it?

My understanding so far is that:

 1. The programming model is event driven, especially the way it handles [I/O][2].
 2. It uses [JavaScript][3] and the parser is [V8][4].
 3. It can be easily used to create concurrent server applications.

Are my understandings correct? If yes, then what are the benefits of evented I/O, is it just more for the concurrency stuff? Also, is the direction of Node.js to become a framework like, JavaScript based (V8 based) programming model?

  [1]: http://en.wikipedia.org/wiki/Node.js
  [2]: http://en.wikipedia.org/wiki/Input/output
  [3]: http://en.wikipedia.org/wiki/JavaScript
  [4]: http://en.wikipedia.org/wiki/V8_%28JavaScript_engine%29


What is Node.js?

I&#39;m getting started with Node.js and I&#39;m having a hard time figuring out what version of JavaScript is supported by node which makes it difficult figuring out what features I can use. Here&#39;s what I know.

 - [Node](http://nodejs.org/) uses V8 
 - [V8](http://code.google.com/p/v8/) implements ECMAScript as specified in ECMA-262, 3rd edition
 - ECMA-262, 3rd edition is [JavaScript 1.5](http://en.wikipedia.org/wiki/JavaScript#Versions)

Given this, I would assume I can use JavaScript 1.5 compatible code in node. However, it turns out I can use the [`Array.forEach`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/foreach), among other constructs, even though according to MDC it isn&#39;t available until Javascript 1.6 -- ECMA-262, 5th edition.

Where am I going wrong? Is there a document somewhere that details the available language features?

What version of Javascript is supported in node.js

Originally asked: *What is the difference between Node.js 4.x branch with LTS (Long Term Support) and the 5.x branch (listed as Stable)?*

But this is equally relevant to understanding the difference between 6.x and 7.x and, in the future, 8.x and 9.x

Generally, I always lean towards the latest version for features and performance (as I now do a lot of ES6 / ES7). Is there any information on how production ready the &quot;stable&quot; branches are?

What are the differences between Long Term Support (LTS) and Stable versions of Node.js?

I&#39;ve seen `process.binding(&#39;...&#39;)` many times while researching through the [node.js source code on github](https://github.com/nodejs/node).

Can anybody explain me what this function does?

Nodejs: What does `process.binding` mean?

A previous poster asked https://stackoverflow.com/questions/6397096/function-bind-vs-closure-in-javascript-how-to-choose

and received this answer in part, which seems to indicate bind should be faster than a closure:

&gt; Scope traversal means, when you are reaching to grab a value
&gt; (variable,object) that exists in a different scope, therefore
&gt; additional overhead is added (code becomes slower to execute).
&gt; 
&gt; Using bind, you &#39;re calling a function with an existing scope, so that
&gt; scope traversal does not take place.

Two jsperfs suggest that bind is actually much, much slower than a [closure][1].

This was posted as a comment to the above

And, I decided to write [my own jsperf][2]


So why is bind so much slower (70+% on chromium)?

Since it is not faster and closures can serve the same purpose, should bind be avoided?


  [1]: http://jsperf.com/bind-vs-closure-performace
  [2]: http://jsperf.com/simple-null-bind-vs-closure

Why is bind slower than a closure?

I am asking this question because I and my colleague have a dispute on coding style because he prefers arrows function declaration:

    const sum = (a, b) =&gt; a + b;

And I prefer old-style standalone function declaration:

    function sum(a, b) {
        return a + b;
    }

My point is that code in old-style more readable and you can more clearly distinguish function and variable declarations. His point is that code with arrow functions just run faster.

Do you know something about actual performance penalties (in v8) when you use old-style standalone function declaration instead of arrow functions? Are that penalties really exists?

Are arrow functions faster (more performant, lighter) than ordinary standalone function declaration in v8?

In a vain attempt to write perfect javascript I am tackling the issue of the Javascript heap. I have got it down to the lowest level I can but I have run out of options, and don&#39;t understand what is going on (well my guess is rAF overhead, but guesses don&#39;t count).

**The heap&#39;s sawtooth pattern (in light blue):**

[![enter image description here][1]][1]

The above timeline is from a simple full page canvas particle render. The aim of the exercise is to reduce the amplitude of the heap&#39;s sawtooth, and hopefully also increase the period between cleanups.

Looking closer, the heap is growing about 15k every 60th of a second, and falling from 3.3MB to 2.4MB every ~1 second

[![enter image description here][2]][2]

What I do not understand is the timing and the growth amount 15K.

The heap grows by 15kb just before execution idle, and ~0.015ms after the following function has return to idle (below is my top level function).

    var renderList = [];    
    var stop = false;
    var i;

    function update(timer) { // Main update loop
        if(!stop){
            requestAnimationFrame(update);
        }
        for(i = 0; i &lt; renderList.length; i ++){
            renderList[i](timer,ctx, w, h);            
        }
    }



Nothing I do to the code is reducing or changing the location of the heap growth. The allocation profile shows that am not allocating any memory. GC is at 0.08% on the CPU profile (what it is doing I don&#39;t know?, does it also manage the heap?)

Can someone please explain to me what this memory is being used for? and how I can reduce it or make the line flat?

I understand that there may be nothing I can do, but at the moment I dont have the vaguest idea what is being put on the heap? It would be nice to know.




The snippet is just the code called from `update` (code snippet above) I don&#39;t think it is relevant, but just in case. It is the code that has executed and returned just before the heap grows.
&lt;!-- begin snippet: js hide: true console: false babel: false --&gt;

&lt;!-- language: lang-js --&gt;

            var p,d,s;
            var renderCount = 0;
            var fxId = 0;
            var lastTime;
            var frameTime = 0;
            var minParticles = 10;
            var particleCount = minParticles;
            var frameSum = 0;
            var frameAve = 0;
            var frameWorkTime = 0;
            var lastFrameWorkTime = 0;
            var particleRenderTimeMax = 0;
            var m = 0;
            var mC = 0;
            var mR = 0;
            var then,tx,ty;
            var renderTime,then1; 

            //=====================================================================================
            // the following function is out of context and just placed here as reference
            /*
            draw : function (image, index, x, y, scale, rotation, alpha) {
                spr = image.sprites[index];
                ctx.setTransform(scale, 0, 0, scale, x, y);
                ctx.rotate(rotation);
                ctx.globalAlpha = alpha;
                sh = spr.h;
                sw = spr.w;
                if(spr.vx !== undefined){  // virtual sprite dimensions
                    _x = -spr.vw / 2 + spr.vx;
                    _y = -spr.vh / 2 + spr.vy;
                    ctx.drawImage(image, spr.x, spr.y, sw, sh, _x, _y, sw, sh);
                    return;
                }
                ctx.drawImage(image, spr.x, spr.y, sw, sh, -sw / 2, -sh / 2, sw, sh);
            },
            */        
            //=====================================================================================        
            
            // Add particle
            function addP(x,y,spr){
                p = particles.fNextFree();
                if(particles.fLength &gt;= particleCount || p === undefined){ // no room for more
                    return;
                }
                p.x = x;
                p.y = y;
                p.spr = spr;
                p.life = 100;
                p.s = Math.random() +0.1
                d = Math.random() * Math.PI * 2;
                s = Math.random() * Math.PI * 2;
                p.dx = Math.cos(d) * s;
                p.dy = Math.sin(d) * s;
                p.dr = Math.random()-0.5;
                p.maxLife = p.life = 100-spr*10;
            }
            // move and draw particle
            function updateDrawP(p,i){
                if(i &gt;= particleCount){
                    p.life = undefined;
                    return;
                }
                s =  p.life/p.maxLife;
                p.x += p.dx * s;
                p.y += p.dy * s;
                p.r += p.dr;
                p.life -= 1;
                
                if(p.life === 0){
                    p.life = undefined;
                    return;
                }
                renderCount += 1;
                sDraw(spriteSheet, p.spr, p.x, p.y, p.s, p.r, s); // Calls draw (function example above)
            }
          
            
            function renderAll(time) { // this is called from a requestAnimationFrame controlled function
                var then = performance.now(); // get frame start time
                var tx, ty;
                if (lastTime !== undefined) {
                    frameTime = time - lastTime;
                    frameSum *= 0.5;
                    frameSum += frameTime;
                    frameAve = frameSum * 0.5; // a running mean render time
                }
                lastTime = time;
                ctx.setTransform(1, 0, 0, 1, 0, 0); // reset transform
                ctx.globalAlpha = 1; // reset alpha
                ctx.clearRect(0, 0, w, h);
                if (spriteSheet.sprites) { 
                    mouseWorld = EZSprites.world.screen2World(mouse.x, mouse.y, mouseWorld);
                    if (mouse.buttonRaw &amp; 1) {
                        fxId += 1;
                        fxId %= EZSprites.FX.namedFX.length;
                        mouse.buttonRaw = 0;
                    }
                    if (mouse.buttonRaw &amp; 4) {
                        world.posX += mouse.x - mouse.lastX;
                        world.posY += mouse.y - mouse.lastY;
                        EZSprites.world.setPosition(world.posX, world.posY);
                        mouseWorld = EZSprites.world.screen2World(mouse.x, mouse.y, mouseWorld);
                    }
                    if (mouse.w !== 0) {
                        if (mouse.w &gt; 0) {
                            EZSprites.world.zoom2Screen(mouse.x, mouse.y, ZOOM_AMOUNT, true);
                            mouse.w -= ZOOM_WHEEL_STEPS;
                        } else {
                            EZSprites.world.zoom2Screen(mouse.x, mouse.y, ZOOM_AMOUNT, false);
                            mouse.w += ZOOM_WHEEL_STEPS
                        }
                        mouseWorld = EZSprites.world.screen2World(mouse.x, mouse.y, mouseWorld);
                        EZSprites.world.getWorld(currentWorld);
                        world.posX = currentWorld.x;
                        world.posY = currentWorld.y;
                    }

                    // sets the current composite operation (only using source-over)
                    EZSprites.FX[EZSprites.FX.namedFX[fxId]]();

                    // render and time particles
                    renderCount = 0;
                    var then1 = performance.now();
                    
                    particles.fEach(updateDrawP); // render all particles
                    
                    var renderTime = performance.now() - then1;

                    EZSprites.context.setDefaults();

                    // gets the total time spent inside this function
                    frameWorkTime += performance.now() - then;
                    lastFrameWorkTime = frameWorkTime;
                    if (renderCount &gt; 0) {
                        particleRenderTimeMax = Math.max(particleRenderTimeMax, renderTime / renderCount);
                        particleRenderTimeMax *= 10;
                        particleRenderTimeMax += renderTime / renderCount
                        particleRenderTimeMax /= 11;
                        // Smooth out per particle render time max
                        m = particleRenderTimeMax;
                        mC += (m - mR) * 0.1;
                        mC *= 0.1;
                        mR += mC;
                        // Particle count is being balanced to keep ensure there is plenty of idle time before
                        // the next frame. Mean time spent in this function is about 8 to 9ms
                        particleCount = Math.floor(((1000 / 120) - (frameWorkTime - renderTime)) / (mR));
                    }
                    // This is where frameWorkTime begins its timing of the function
                    then = performance.now();
                    frameWorkTime = 0;

                    if (particleCount &lt;= maxParticles) {
                        particles.fMaxLength = particleCount;
                    }
                    // Add particles. 
                    addP(mouse.x, mouse.y, 1);
                    addP(mouse.x, mouse.y, 2);
                    addP(mouse.x, mouse.y, 3);
                    addP(mouse.x, mouse.y, 4);
                    addP(mouse.x, mouse.y, 5);
                    addP(mouse.x, mouse.y, 1);
                    addP(mouse.x, mouse.y, 2);
                    addP(mouse.x, mouse.y, 3);
                    addP(mouse.x, mouse.y, 4);
                    addP(mouse.x, mouse.y, 5);
                }
                mouse.lastX = mouse.x;
                mouse.lastY = mouse.y;
                frameWorkTime = performance.now() - then;
            }

&lt;!-- end snippet --&gt;





----

## Update snippet

As asked in comments below is reproducible HTML doc. 

**Note** this example can not be hosted in sites like CodePen or StackOverflow as they modify monitor and or execute source of addition code that interferes with the test

```
&lt;!DOCTYPE html&gt;
&lt;html&gt;
    &lt;head&gt;&lt;meta http-equiv=&quot;Content-Type&quot; content=&quot;text/html;charset=ISO-8859-8&quot;&gt;&lt;/head&gt;
    &lt;body&gt;&lt;script&gt; 
	&quot;use strict&quot;;
	(() =&gt; {
		var renderList = [], stop = false, i, ctx;
		requestAnimationFrame(function update(timer) { // Main loop
			if (!stop) { requestAnimationFrame(update) }
			for (i = 0; i &lt; renderList.length; i ++){
				renderList[i](timer, ctx, w, h);            
			}
		});
	})();
    &lt;/script&gt;&lt;/body&gt;
&lt;/html&gt;
```

Running the above example has the heap grow over 60secs before a major GC is called with the heap growing approx ~300bytes per frame.

----







  [1]: https://i.stack.imgur.com/4zxkO.jpg
  [2]: https://i.stack.imgur.com/GTtSV.jpg

Understanding JavaScript heap growth and GC pattern

My website has been broken since Dreamhost upgraded their servers a couple of weeks ago. I have been tearing my hair out trying to get it fixed and made some progress but am stuck on what is hopefully the final issue.

I&#39;m using Rails 3.1.1 on Ruby 1.8.7 and get presented with a &#39;Ruby (Rack) application could not be started error&#39; from PhusionPassenger. It states that it &#39;Could not find a JavaScript runtime. See https://github.com/sstephenson/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)&#39;. Searching for this on Dreamhost&#39;s wiki has suggested a solution to install &#39;therubyracer&#39; gem.

So I updated my gemfile with the suggested gem like so:

&gt; gem &#39;therubyracer&#39;, &#39;~&gt; 0.9.9&#39;

EDIT: I have also tried adding to the file with: 
&gt; gem &#39;therubyracer&#39;, :platforms =&gt; :ruby

but it hasn&#39;t made a difference.

Then bundle installed on my Macbook (running OS X 10.5.8) without hitch. However, this fails when I run &#39;cap deploy&#39; to put on Dreamhost; I see an error when it attempts to install libv8 which therubyracer depends on.

Anyone know how to get this to install correctly or any other working solution?

Any other info can be provided upon request.

Full error feedback from Terminal:

&gt; * executing &quot;cd /home/futureproof/abunchofletters.co.uk/releases/20111118003703 &amp;&amp;
&gt; bundle install --gemfile
&gt; /home/futureproof/abunchofletters.co.uk/releases/20111118003703/Gemfile
&gt; --path /home/futureproof/.gems/bundle --deployment --quiet --without development test&quot;
&gt;     servers: [&quot;abunchofletters.co.uk&quot;]
&gt;     [abunchofletters.co.uk] executing command  ** [out :: abunchofletters.co.uk] Unfortunately, a fatal error has occurred.
&gt; Please report this error to the Bundler issue tracker at
&gt; https://github.com/carlhuda/bundler/issues so that we can fix it.
&gt; Thanks!  ** [out :: abunchofletters.co.uk]
&gt; /usr/lib/ruby/1.8/rubygems/installer.rb:483:in `build_extensions&#39;:
&gt; ERROR: Failed to build gem native extension.
&gt; (Gem::Installer::ExtensionBuildError)  ** [out ::
&gt; abunchofletters.co.uk]   ** [out :: abunchofletters.co.uk]
&gt; /usr/bin/ruby1.8 extconf.rb  ** [out :: abunchofletters.co.uk] ***
&gt; extconf.rb failed ***  ** [out :: abunchofletters.co.uk] Could not
&gt; create Makefile due to some reason, probably lack of  ** [out ::
&gt; abunchofletters.co.uk] necessary libraries and/or headers.  Check the
&gt; mkmf.log file for more  ** [out :: abunchofletters.co.uk] details. 
&gt; You may need configuration options.  ** [out :: abunchofletters.co.uk]
&gt; ** [out :: abunchofletters.co.uk] Provided configuration options:  ** [out :: abunchofletters.co.uk] --with-opt-dir  ** [out ::
&gt; abunchofletters.co.uk] --without-opt-dir  ** [out ::
&gt; abunchofletters.co.uk] --with-opt-include  ** [out ::
&gt; abunchofletters.co.uk] --without-opt-include=${opt-dir}/include  **
&gt; [out :: abunchofletters.co.uk] --with-opt-lib  ** [out ::
&gt; abunchofletters.co.uk] --without-opt-lib=${opt-dir}/lib  ** [out ::
&gt; abunchofletters.co.uk] --with-make-prog  ** [out ::
&gt; abunchofletters.co.uk] --without-make-prog  ** [out ::
&gt; abunchofletters.co.uk] --srcdir=.  ** [out :: abunchofletters.co.uk]
&gt; --curdir  ** [out :: abunchofletters.co.uk] --ruby=/usr/bin/ruby1.8  ** [out :: abunchofletters.co.uk] extconf.rb:13: uninitialized constant Gem (NameError)  ** [out :: abunchofletters.co.uk] Checking
&gt; for Python...  ** [out :: abunchofletters.co.uk]   ** [out ::
&gt; abunchofletters.co.uk] Gem files will remain installed in
&gt; /home/futureproof/.gems/bundle/ruby/1.8/gems/libv8-3.3.10.4 for
&gt; inspection.  ** [out :: abunchofletters.co.uk] Results logged to
&gt; /home/futureproof/.gems/bundle/ruby/1.8/gems/libv8-3.3.10.4/ext/libv8/gem_make.out
&gt; ** [out :: abunchofletters.co.uk] from /usr/lib/ruby/1.8/rubygems/installer.rb:446:in `each&#39;  ** [out ::
&gt; abunchofletters.co.uk] from
&gt; /usr/lib/ruby/1.8/rubygems/installer.rb:446:in `build_extensions&#39;  **
&gt; [out :: abunchofletters.co.uk] from
&gt; /usr/lib/ruby/1.8/rubygems/installer.rb:198:in `install&#39;  ** [out ::
&gt; abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/source.rb:90:in
&gt; `install&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/rubygems_integration.rb:78:in
&gt; `preserve_paths&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/source.rb:89:in
&gt; `install&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/installer.rb:73:in
&gt; `install_gem_from_spec&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/rubygems_integration.rb:93:in
&gt; `with_build_args&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/installer.rb:72:in
&gt; `install_gem_from_spec&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/installer.rb:56:in
&gt; `run&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/installer.rb:55:in
&gt; `run&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/installer.rb:12:in
&gt; `install&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/cli.rb:219:in
&gt; `install&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/vendor/thor/task.rb:22:in
&gt; `send&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/vendor/thor/task.rb:22:in
&gt; `run&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/vendor/thor/invocation.rb:118:in
&gt; `invoke_task&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/vendor/thor.rb:263:in
&gt; `dispatch&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/lib/bundler/vendor/thor/base.rb:386:in
&gt; `start&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/gems/bundler-1.1.rc/bin/bundle:13  ** [out ::
&gt; abunchofletters.co.uk] from /home/futureproof/.gems/bin/bundle:19:in
&gt; `load&#39;  ** [out :: abunchofletters.co.uk] from
&gt; /home/futureproof/.gems/bin/bundle:19
&gt;     command finished in 13170ms
&gt; *** [deploy:update_code] rolling back   * executing &quot;rm -rf /home/futureproof/abunchofletters.co.uk/releases/20111118003703; true&quot;
&gt;     servers: [&quot;abunchofletters.co.uk&quot;]
&gt;     [abunchofletters.co.uk] executing command
&gt;     command finished in 563ms failed: &quot;sh -c &#39;cd /home/futureproof/abunchofletters.co.uk/releases/20111118003703 &amp;&amp;
&gt; bundle install --gemfile
&gt; /home/futureproof/abunchofletters.co.uk/releases/20111118003703/Gemfile
&gt; --path /home/futureproof/.gems/bundle --deployment --quiet --without development test&#39;&quot; on abunchofletters.co.uk

Rails: Could not find a JavaScript runtime. See https://github.com/sstephenson/execjs for a list of available runtimes. (ExecJS::RuntimeUnavailable)

I would appreciate some help in getting `gem install therubyracer` to work. Here is the error:

    $ gem install therubyracer
    Building native extensions.  This could take a while...
    ERROR:  Error installing therubyracer:
    	ERROR: Failed to build gem native extension.
    
            /Users/david/.rvm/rubies/ruby-1.9.3-p194/bin/ruby extconf.rb
    checking for main() in -lobjc... yes
    *** extconf.rb failed ***
    Could not create Makefile due to some reason, probably lack of
    necessary libraries and/or headers.  Check the mkmf.log file for more
    details.  You may need configuration options.
    
    Provided configuration options:
    	--with-opt-dir
    	--with-opt-include
    	--without-opt-include=${opt-dir}/include
    	--with-opt-lib
    	--without-opt-lib=${opt-dir}/lib
    	--with-make-prog
    	--without-make-prog
    	--srcdir=.
    	--curdir
    	--ruby=/Users/david/.rvm/rubies/ruby-1.9.3-p194/bin/ruby
    	--with-objclib
    	--without-objclib
    extconf.rb:15:in `&lt;main&gt;&#39;: undefined method `include_path&#39; for Libv8:Module (NoMethodError)

Here are some notable steps that I ran before the error. They worked fine:

    $ gem install libv8
    $ brew install v8

My environment is:

* Mac OS X Lion 10.7.4
* ruby 1.9.3p194 (2012-04-20 revision 35410) [x86_64-darwin11.4.0] (via rvm)
* V8 version 3.9.24 (via homebrew)


`gem install therubyracer` fails on Mac OS X Lion

After sweating blood and tears I&#39;ve finally managed to set up a Node C++ addon and shove a web-platform standard `MediaStream` object into one of its C++ methods for good. For compatibility across different V8 and Node.js versions, I&#39;m using [Native Abstractions for Node.js (nan)](https://github.com/nodejs/nan):

**addon.cc**

    NAN_METHOD(SetStream)
    {
        Nan::HandleScope scope;
        v8::Local&lt;v8::Object&gt; mediaStream = info[0]-&gt;ToObject();
    }

**addon.js**

    setStream(new MediaStream());

For what it&#39;s worth, this works correctly (i.e. it does not obliterate the renderer process on sight), and I can verify the presence of the `MediaStream` object, e.g. by returning its constructor name from the C++ method:

**addon.cc**

    info.GetReturnValue().Set(mediaStream-&gt;GetConstructorName());

When called from JavaScript through `setStream`, this would return the string *`MediaStream`*, so the object is definitely there. I can also return the `mediaStream` object itself and everything will work correctly, so it&#39;s indeed the object I need.

**So, how would I read audio data (i.e. audio samples) from this `MediaStream` object in C++?** As a sidenote, the actual data read (and processing) would be done in a separate `std::thread`.

-----

## Bounty Update

I understand this would be sort of easier/possible if I were compiling Electron and/or Chromium myself, but I&#39;d rather not get involved in that maintenance hell.

I was wondering if it would be possible without doing that, and as far as my research goes, I&#39;m convinced I need 2 things to get this done:

 1. The relevant header files, for which I believe [blink public](https://chromium.googlesource.com/chromium/blink-public/) should be adequate
 2. A chromium/blink library file (?), to resolve external symbols, similarly to the node.dylib file

Also, as I said, I believe I could compile chromium/blink myself and then I would have this lib file, but that would be a maintenance hell with Electron. With this in mind, I believe this question ultimately comes down to a C++ linking question. Is there any other approach to do what I&#39;m looking for?

### Edit

ScriptProcessorNode is not an option in my case, as its performance makes it nearly unusable in production. This would require to process audio samples on the ui/main thread, which is absolutely insane.


### Edit 2

[AudioWorklets](https://developer.mozilla.org/en-US/docs/Web/API/AudioWorklet) have been available in Electron for some time now, which, unlike the ScriptProcessorNode (or worse, the AnalyzerNode), is low-latency and very reliable for true C++ backed audio processing even in real time.

If someone wants to go ahead and write an AudioWorklet-based answer, I&#39;ll gladly accept, but beware: it&#39;s a _very_ advanced field and a very deep rabbit hole, with countless obstacles to get through even before a very simple, general-purpose pass-through prototype (especially so because currently in Electron, Atomics-synced, buffered cross-thread audio processing is required to pull this off because https://github.com/electron/electron/issues/22503 -- although getting a native C++ addon into one audio renderer thread, let alone multiple threads at the same time, is probably equally as challenging).

How to read audio data from a &#39;MediaStream&#39; object in a C++ addon

Is it a fair assumption that in v8 implementation retrieval / lookup is O(1)?

(I know that the standard doesn&#39;t guarantee that)



es6 Map and Set complexity, v8 implementation

I am confused about JavaScript engines right now. I know that [V8][1] was a big deal because it compiled JavaScript to native code. 

Then I started reading about [Mozilla SpiderMonkey][2], which from what I understand is written in C and can compile JavaScript. So how is this different from V8 and if this is true, why does Firefox not do this?

Finally, does [Rhino][3] literally compile the JavaScript to Java byte code so you would get all the speed advantages of Java? If not, why do people not run V8 when writing scripts on their desktops?


  [1]: https://code.google.com/p/v8/
  [2]: https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey
  [3]: https://developer.mozilla.org/en-US/docs/Rhino

Javascript Engines Advantages

JavaScript developers who have spent time in languages like C often miss the ability to use certain types of introspection, like logging line numbers, and what method the current method was invoked from. Well if you&#39;re using V8 (Chrome, Node.js) you can employ the following.

Accessing line number in V8 JavaScript (Chrome &amp; Node.js)

I&#39;ve been trying to make an experiment to see if the local variables in functions are stored on a stack.

So I wrote a little performance test

    function test(fn, times){
        var i = times;
        var t = Date.now()
        while(i--){
            fn()
        }
        return Date.now() - t;
    } 
    ene
    function straight(){
        var a = 1
        var b = 2
        var c = 3
        var d = 4
        var e = 5
        a = a * 5
        b = Math.pow(b, 10)
        c = Math.pow(c, 11)
        d = Math.pow(d, 12)
        e = Math.pow(e, 25)
    }
    function inversed(){
        var a = 1
        var b = 2
        var c = 3
        var d = 4
        var e = 5
        e = Math.pow(e, 25)
        d = Math.pow(d, 12)
        c = Math.pow(c, 11)
        b = Math.pow(b, 10)
        a = a * 5
    }

I expected to get inversed function work much faster. Instead an amazing result came out.

Untill I test one of the functions it runs 10 times faster than after testing the second one.

Example:
    
    &gt; test(straight, 10000000)
    30
    &gt; test(straight, 10000000)
    32
    &gt; test(inversed, 10000000)
    390
    &gt; test(straight, 10000000)
    392
    &gt; test(inversed, 10000000)
    390
Same behaviour when tested in alternative order.

    &gt; test(inversed, 10000000)
    25
    &gt; test(straight, 10000000)
    392
    &gt; test(inversed, 10000000)
    394


I&#39;ve tested it both in the Chrome browser and in Node.js and I&#39;ve got absolutely no clue why would it happen.
The effect lasts till I refresh the current page or restart Node REPL.

What could be a source of such significant (~12 times worse) performance?

PS. Since it seems to work only in some environemnts please write the environment You&#39;re using to test it.

Mine were:  

OS: Ubuntu 14.04  
Node v0.10.37  
Chrome 43.0.2357.134 (Official Build) (64-bit)  

/Edit  
On Firefox 39 it takes ~5500 ms for each test regardless of the order. It seems to occur only on specific engines.

/Edit2  
Inlining the function to the test function makes it run always the same time.   
Is it possible that there is an optimization that inlines the function parameter if it&#39;s always the same function?

What makes this function run much slower?

Is there any way to efficiently check if the variable is Object or Array, in NodeJS &amp; V8? 

I&#39;m writing a Model for MongoDB and NodeJS, and to traverse the object tree I need to know if the object is simple (Number, String, ...) or composite (Hash, Array).

It seems that V8 has fast built-in `Array.isArray`, but how to check if object is an Object? I mean complex object like hash `{}` or instance of class, not something like `new String()`?

Usually it may be done as this:

    Object.prototype.toString.call(object) == &quot;[object Object]&quot;

or this:

    object === Object(object)

But it seems that this operations aren&#39;t cheap, maybe there&#39;s some more efficient? It&#39;s ok if it&#39;s not universal and doesn&#39;t works on all engines, I need it only to work on V8.

How to efficiently check if variable is Array or Object (in NodeJS &amp; V8)?

I&#39;ve been thinking about this question for a while and can&#39;t seem to find the answer. What is the relationship between Node.js and V8? and Can Node.js work without V8?

What is the relationship between Node.js and V8?

We&#39;re experimenting with using `--harmony_async_await` in Node 7, and compared to transpiling with babel for async/await are missing the ability to have long stack traces (http://bluebirdjs.com/docs/api/promise.longstacktraces.html).

Obviously, it would be great if there was an option to &#39;just see this&#39; - on the chrome(ium) side they appear to support it in the inspector, though the latest work on this is after v8.5.4 (i.e. not in Node 7):

https://bugs.chromium.org/p/v8/issues/detail?id=4483

https://codereview.chromium.org/2357423002/

An alternative approach would be to get v8 to use bluebird&#39;s promise implementation - but how could I do that? Overriding `global. Promise` doesn&#39;t change how async/await behave (they still use the default promises).

Is it possible to get stack traces across async/await boundaries using --harmony_async_await in Node 7?

I wanted to use `for each ... in` with Node.js (v0.4.11).

I use it like this:

    var conf = {
       index: {
          path: {
             first: &quot;index.html&quot;,
             pattern: &quot;index/{num}.html&quot;
          },
          template: &quot;index.tpl&quot;,
          limit: 8
       },
       feed: {
          path: &quot;feed.xml&quot;,
          template: &quot;atom.tpl&quot;,
          limit: 8
       }
    }

    for each (var index in conf) {
      console.log(index.path);
    }

I get the following error:

&lt;!-- language: lang-none --&gt;

            for each (var index in conf) {
         ^^^^
    
    node.js:134
            throw e; // process.nextTick error, or &#39;error&#39; event on first tick
            ^
    SyntaxError: Unexpected identifier
        at Module._compile (module.js:397:25)
        at Object..js (module.js:408:10)
        at Module.load (module.js:334:31)
        at Function._load (module.js:293:12)
        at require (module.js:346:19)
        at Object.&lt;anonymous&gt; (/home/paul/dev/indexing/lib/Index.js:3:13)
        at Module._compile (module.js:402:26)
        at Object..js (module.js:408:10)
        at Module.load (module.js:334:31)
        at Function._load (module.js:293:12)

Where is the mistake? `for each ... in` is supported since Javascript 1.6.

See [MDN](https://developer.mozilla.org/en/JavaScript/Reference/Statements/for_each...in) for information about the usage of `for each ... in`.

Node.js: for each … in not working

# Preface

**This issue seems to only affect Chrome/V8, and may not be reproducible in Firefox or other browsers**. In summary, the execution time of a function callback increases by an order of magnitude or more if the function is called with a new callback anywhere else. 

## Simplified Proof-of-Concept

Calling `test(callback)` arbitrarily many times works as expected, but once you call `test(differentCallback)`, the execution time of the `test` function increases dramatically no matter what callback is provided (i.e., another call to `test(callback)` would suffer as well). 

**This example was updated to use arguments so as to not be optimized to an empty loop. Callback arguments `a` and `b` are summed and added to `total`, which is logged.** 

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    function test(callback) {
        let start = performance.now(),
            total = 0;

        // add callback result to total
        for (let i = 0; i &lt; 1e6; i++)
            total += callback(i, i + 1);

        console.log(`took ${(performance.now() - start).toFixed(2)}ms | total: ${total}`);
    }

    let callback1 = (a, b) =&gt; a + b,
        callback2 = (a, b) =&gt; a + b;

    console.log(&#39;FIRST CALLBACK: FASTER&#39;);
    for (let i = 1; i &lt; 10; i++)
        test(callback1);

    console.log(&#39;\nNEW CALLBACK: SLOWER&#39;);
    for (let i = 1; i &lt; 10; i++)
        test(callback2);

&lt;!-- end snippet --&gt;

---

## Original post

I am developing a `StateMachine` class ([source][1]) for a library I&#39;m writing and the logic works as expected, but in profiling it, I&#39;ve run into an issue. I noticed that when I ran the profiling snippet (in global scope), it would only take about 8ms to finish, but if I ran it a second time, it would take up to 50ms and eventually balloon as high as 400ms. Typically, running the same named function over and over will cause its execution time to *drop* as the V8 engine optimizes it, but the opposite seems to be happening here. 

I&#39;ve been able to get rid of the problem by wrapping it in a closure, but then I noticed another weird side effect: Calling a different function that relies on the `StateMachine` class would break the performance for all code depending on the class. 

The class is pretty simple - you give it an initial state in the constructor or `init`, and you can update the state with the `update` method, which you pass a callback that accepts `this.state` as an argument (and usually modifies it). `transition` is a method that is used to `update` the state until the `transitionCondition` is no longer met.

Two test functions are provided: `red` and `blue`, **which are identical**, and each will generate a `StateMachine` with an initial state of `{ test: 0 }` and use the `transition` method to `update` the state while `state.test &lt; 1e6`. The end state is `{ test: 1000000 }`.

You can trigger the profile by clicking the red or blue button, which will run `StateMachine.transition` 50 times and log the average time the call took to complete. If you click the red or blue button repeatedly, you will see that it clocks in at less than 10ms without issue - *but*, once you click the *other* button and call the other version of the same function, everything breaks, and the execution time for both functions will increase by about an order of magnitude. 

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    // two identical functions, red() and blue()

    function red() {
      let start = performance.now(),
          stateMachine = new StateMachine({
            test: 0
          });

      stateMachine.transition(
        state =&gt; state.test++, 
        state =&gt; state.test &lt; 1e6
      );

      if (stateMachine.state.test !== 1e6) throw &#39;ASSERT ERROR!&#39;;
      else return performance.now() - start;
    }

    function blue() {
      let start = performance.now(),
          stateMachine = new StateMachine({
            test: 0
          });

      stateMachine.transition(
        state =&gt; state.test++, 
        state =&gt; state.test &lt; 1e6
      );

      if (stateMachine.state.test !== 1e6) throw &#39;ASSERT ERROR!&#39;;
      else return performance.now() - start;
    }

    // display execution time
    const display = (time) =&gt; document.getElementById(&#39;results&#39;).textContent = `Avg: ${time.toFixed(2)}ms`;

    // handy dandy Array.avg()
    Array.prototype.avg = function() {
      return this.reduce((a,b) =&gt; a+b) / this.length;
    }

    // bindings
    document.getElementById(&#39;red&#39;).addEventListener(&#39;click&#39;, () =&gt; {
      const times = [];
      for (var i = 0; i &lt; 50; i++)
        times.push(red());
        
      display(times.avg());
    }),

    document.getElementById(&#39;blue&#39;).addEventListener(&#39;click&#39;, () =&gt; {
      const times = [];
      for (var i = 0; i &lt; 50; i++)
        times.push(blue());
        
      display(times.avg());
    });

&lt;!-- language: lang-html --&gt;

    &lt;script src=&quot;https://cdn.jsdelivr.net/gh/TeleworkInc/state-machine@bd486a339dca1b3ad3157df20e832ec23c6eb00b/StateMachine.js&quot;&gt;&lt;/script&gt;

    &lt;h2 id=&quot;results&quot;&gt;Waiting...&lt;/h2&gt;
    &lt;button id=&quot;red&quot;&gt;Red Pill&lt;/button&gt;
    &lt;button id=&quot;blue&quot;&gt;Blue Pill&lt;/button&gt;

    &lt;style&gt;
    body{box-sizing:border-box;padding:0 4rem;text-align:center}button,h2,p{width:100%;margin:auto;text-align:center;font-family:-apple-system,BlinkMacSystemFont,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;,&quot;Segoe UI Symbol&quot;}button{font-size:1rem;padding:.5rem;width:180px;margin:1rem 0;border-radius:20px;outline:none;}#red{background:rgba(255,0,0,.24)}#blue{background:rgba(0,0,255,.24)}
    &lt;/style&gt;

&lt;!-- end snippet --&gt;

# Updates
### [&lt;strike&gt;Bug Report&lt;/strike&gt; &quot;Feature Request&quot; filed](https://bugs.chromium.org/p/v8/issues/detail?id=10676) (awaiting update) - See @jmrk&#39;s answers below for more details. 

Ultimately, this behavior is unexpected and, IMO, qualifies as a nontrivial bug. The impact for me is significant - on Intel i7-4770 (8) @ 3.900GHz, my execution times in the example above go from an average of 2ms to 45ms (a 20x increase).

As for nontriviality, consider that any *subsequent* calls to `StateMachine.transition`  after the first one will be unnecessarily slow, regardless of scope or location in the code. The fact that SpiderMonkey does not slow down subsequent calls to `transition` signals to me that there is room for improvement for this specific optimization logic in V8.

See below, where subsequent calls to `StateMachine.transition` are slowed:

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    // same source, several times

    // 1
    (function() {
      let start = performance.now(),
        stateMachine = new StateMachine({
          test: 0
        });

      stateMachine.transition(state =&gt; state.test++, state =&gt; state.test &lt; 1e6);

      if (stateMachine.state.test !== 1e6) throw &#39;ASSERT ERROR!&#39;;
      console.log(`took ${performance.now() - start}ms`);
    })();


    // 2 
    (function() {
      let start = performance.now(),
        stateMachine = new StateMachine({
          test: 0
        });

      stateMachine.transition(state =&gt; state.test++, state =&gt; state.test &lt; 1e6);

      if (stateMachine.state.test !== 1e6) throw &#39;ASSERT ERROR!&#39;;
      console.log(`took ${performance.now() - start}ms`);
    })();

    // 3
    (function() {
      let start = performance.now(),
        stateMachine = new StateMachine({
          test: 0
        });

      stateMachine.transition(state =&gt; state.test++, state =&gt; state.test &lt; 1e6);

      if (stateMachine.state.test !== 1e6) throw &#39;ASSERT ERROR!&#39;;
      console.log(`took ${performance.now() - start}ms`);
    })();

&lt;!-- language: lang-html --&gt;

    &lt;script src=&quot;https://cdn.jsdelivr.net/gh/TeleworkInc/state-machine@bd486a339dca1b3ad3157df20e832ec23c6eb00b/StateMachine.js&quot;&gt;&lt;/script&gt;

&lt;!-- end snippet --&gt;

This performance decrease can be avoided by wrapping the code in a *named* closure, where presumably the optimizer knows the callbacks will not change:

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    var test = (function() {
        let start = performance.now(),
            stateMachine = new StateMachine({
                test: 0
            });
      
        stateMachine.transition(state =&gt; state.test++, state =&gt; state.test &lt; 1e6);
      
        if (stateMachine.state.test !== 1e6) throw &#39;ASSERT ERROR!&#39;;
        console.log(`took ${performance.now() - start}ms`);
    });

    test();
    test();
    test();

&lt;!-- language: lang-html --&gt;

    &lt;script src=&quot;https://cdn.jsdelivr.net/gh/TeleworkInc/state-machine@bd486a339dca1b3ad3157df20e832ec23c6eb00b/StateMachine.js&quot;&gt;&lt;/script&gt;

&lt;!-- end snippet --&gt;

&lt;h1&gt;Platform Information&lt;/h1&gt;

```none
$ uname -a
Linux workspaces 5.4.0-39-generic #43-Ubuntu SMP Fri Jun 19 10:28:31 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux

$ google-chrome --version
Google Chrome 83.0.4103.116
```


  [1]: https://cdn.jsdelivr.net/gh/TeleworkInc/StateMachine.js@bd486a339dca1b3ad3157df20e832ec23c6eb00b/StateMachine.js
  [2]: https://bugs.chromium.org/p/v8/issues/detail?id=10676

Why is the execution time of this function call changing?

I have a function that checks to see whether or not a request has any queries, and does different actions based off that. Currently, I have `if(query)` do this else something else. However, it seems that when there is no query data, I end up with a `{}` JSON object. As such, I need to replace `if(query)` with `if(query.isEmpty())` or something of that sort. Can anybody explain how I could go about doing this in NodeJS? Does the V8 JSON object have any functionality of this sort?

All V8 Solutions on Gang of Coders

Total of 41 V8 Solutions