spidermonkey | DEFUNCT : PHP Web Spider | Crawler library

An array in JavaScript is not a separate type, but a subclass of object (an instance of the class Array, in fact). The array (and list) semantics are layered on top of the behavior that you get automatically with every object in JavaScript. Javascript objects are actually instances of the associative array abstract data type, also known as a dictionary, map, table, etc., and as such can have arbitrarily-named properties.

The rest of the section of the MDN docs you quoted is important:

Setting or accessing via non-integers using bracket notation (or dot notation) will not set or retrieve an element from the array list itself, but will set or access a variable associated with that array's object property collection. The array's object properties and list of array elements are separate, and the array's traversal and mutation operations cannot be applied to these named properties.

So sure, you can always set arbitrary properties on an array, because it's an object. When you do this, you might, depending on implementation, get a weird-looking result when you display the array in the console. But if you iterate over the array using the standard mechanisms (the for...of loop or .forEach method), those properties are not included:

I recommend you read this answer as it explains it quite clearly. In a nutshell, unrolling won't mean that the code will run faster.

For example, if, instead of a simple counter++, you had a function call (taken from the linked answer):

I'm not a "babel" expert, but after a few hours, that is what I've found out. There is no documentation about API rather than the actual source code.

As an example, I've decided to use this plugin, called babel-plugin-transform-spread. Open those links as we go further.

The first stop is AST Spec. In the source code of the plugin above I see some CallExpression, which can easily be found in the spec. According to spec, this Type has a couple of properties (e.g. callee and arguments). And I can see a clear usage of them in the source code too. Nothing special at this point.

But you might want to ask: okay, but what about methods?

Let's have a look at ArrayExpression for example. There are no methods in the spec. But in the source code, there are a lot of them, like .replaceWith(). Where the heck did this come from? I found this API doc. Quite old, yes, but still helpful IMO. Try to find replaceWith on this page and you will see some hints like babel-core.traverse.NodePath.prototype.replaceWith.

Okay, the next step is to open babel's GitHub page and to find something about replaceWith in babel/packages/babel-traverse. That leads us to this line. And right here you can see other related methods.

As an exercise, you can open babel handbook and try to find something else. getPrevSibling for example. And again, open GitHub, open search, see the results, and here we go. Or findParent, or insertAfter, etc.

This method is not the easiest one, but without proper documentation, this is what we have to deal with. Unfortunately.

V8 developer here. It's not a bug, it's just an optimization that V8 doesn't do. It's interesting to see that Firefox seems to do it...

FWIW, I don't see "ballooning to 400ms"; instead (similar to Jon Trent's comment) I see about 2.5ms at first, and then around 11ms.

Here's the explanation:

When you click only one button, then transition only ever sees one callback. (Strictly speaking it's a new instance of the arrow function every time, but since they all stem from the same function in the source, they're "deduped" for type feedback tracking purposes. Also, strictly speaking it's one callback each for stateTransition and transitionCondition, but that just duplicates the situation; either one alone would reproduce it.) When transition gets optimized, the optimizing compiler decides to inline the called function, because having seen only one function there in the past, it can make a high-confidence guess that it's also always going to be that one function in the future. Since the function does extremely little work, avoiding the overhead of calling it provides a huge performance boost.

Once the second button is clicked, transition sees a second function. It must get deoptimized the first time this happens; since it's still hot it'll get reoptimized soon after, but this time the optimizer decides not to inline, because it's seen more than one function before, and inlining can be very expensive. The result is that from this point onwards, you'll see the time it takes to actually perform these calls. (The fact that both functions have identical source doesn't matter; checking that wouldn't be worth it because outside of toy examples that would almost never be the case.)

There's a workaround, but it's something of a hack, and I don't recommend putting hacks into user code to account for engine behavior. V8 does support "polymorphic inlining", but (currently) only if it can deduce the call target from some object's type. So if you construct "config" objects that have the right functions installed as methods on their prototype, you can get V8 to inline them. Like so:

Yes, the internal workings differ. I believe the difference you are noticing here is actually because in WebKit browsers, like Chrome and Safari, console.log is asynchronous, whereas in Firefox (and Node.js) it is strictly synchronous.

I first read about this in the book Async JavaScript by Trevor Burnham. You can find the relevant section of the book by going to this Google Books search link for Async JavaScript and the relevant page should be the first response at the top.

WebKit's console.log has surprised many a developer by behaving asynchronously.

To help understand what is going on, try simply entering this into the console:

Instructions from the answer above were moved to a new location https://theqwertiest.github.io/foo_spider_monkey_panel/docs/for_developers/building_spidermonkey

PS: esr68 branch (as well as master branch) has a slightly different build procedure and requires additional patching to be compatible with MSVC. The linked instructions will be updated once I start using the corresponding branch.

PPS: I had to post an answer instead of comment due to the lack of rep.

PPPS: Never expected anyone to actually use this guide =)

V8 developer here. This looks like a bug. Please file a bug at crbug.com/v8/new.

What this experiment tells you is that in Chrome, JavaScript execution and gif animation/drawing are happening on separate threads (or possibly even separate processes). Just because JavaScript is single-threaded doesn't mean that the entire rest of the browser also has to run on that same thread. Your infinite loop will still prevent additional events from being processed, because control never returns to the event loop -- but the event loop is a JavaScript concept, and gifs don't need to care about it.

Here is an updated experiment to demonstrate that:

I added an option --disable-e10s when launching Firefox, i.e running ./mach run --disable-e10s --debug, it now breaks on all breakpoints in the script.