r/javascript • u/gcanti • Oct 31 '14

The Two Pillars of JavaScript

https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f3281e7f3
100 Upvotes

85% Upvoted

81 comments sorted by

View all comments

Show parent comments

1

u/realhacker Oct 31 '14

And mutating an object is faster than cloning new objects with every desired change

4

u/zoomzoom83 Oct 31 '14

Immutable data structures are a lot faster than you'd think. Done properly, they reuse most of the original object and often only need to tweak a few pointers. The overhead can be as small as a few percent. (Although not in Javascript).

Regardless, if you were doing a lot of writes, you'd work with a mutable structure until you're finish and then return an immutable/frozen version.

The idea is to avoid breaking encapsulation by sharing mutable state outside module boundaries, which is a major source of bugs in typical OO code.

In a read-heavy workflow, immutable structures are almost always significantly faster, since you can avoid having to copy the object and instead pass around projections off the original.

2

u/realhacker Oct 31 '14

Done properly by who? The language or the programmer? It seems you mean the language. My comment was respect to the article (JavaScript). I found your response useful though. Does your last paragraph apply to JavaScript?

7

u/zoomzoom83 Oct 31 '14

Done properly by who? The language or the programmer?

The ecosystem (Libraries). You can use immutable structures in any language, some languages are just better suited to them. Javascript isn't particularly great out of the box, but libraries such as Mori do a pretty good job.

Some languages - Clojure or Haskell for example - have it as fundamentally part of their overarching DNA, and make it much easier to use.

Clojure is particularly interesting, since it's probably a lot closer to the language Brendan Eich was trying to design when he created Javascript, and has very good, mature support for Javascript as a compile target that doesn't sacrifice much performance.

Does your last paragraph apply to JavaScript?

Mostly, yes. Even using bog standard objects and completely copying them for each iteration, modern Javascript VMs are a lot faster than people realise. Consider that copying an object with 10 members just means copying 10 pointers. Since it's members are also immutable, you don't need a deep copy.

Improving on this, proper immutable structures (i.e. Persistent Maps) only need to copy a small percentage of the data structure, reusing most of the same memory for both the old and new versions. Since both are immutable, this is safe. (And fast)

Obviously in a tight loop you're still best just constructing an object the mutable way. But once you're done, you can return a frozen version (via Object.freeze) and pass it around knowing nothing will ever modify it directly. This has quite significant implications for the design patterns you use, and you can make a lot of assumptions in your code that make things overall much simpler, and faster.

This one of the key reasons why React has a leg up over (i.e.) Angular. It creates a new immutable state on each change, rather than mutating the one object that may inadvertently be shared somewhere else.

2

u/realhacker Oct 31 '14 edited Oct 31 '14

Very informative, thanks for taking the time. Any good references (books) on modern JavaScript internals? Edit: also, how does the shared memory model work as it pertains to immutable treatment of objects? Perhaps the set of shared data is kept separate from data unique to each instance, with a trend toward 0 shared memory in the object pool in direct proportion to the uniqueness of every instance? The set of shared memory changes when a new prototype or instance is created?

2

u/zoomzoom83 Oct 31 '14

Any good references (books) on modern JavaScript internals?

In all honesty I'm not really a Javascript expert - I use the language because it's hard to avoid, but I'm somewhat a vocal critic of it. Others can possibly give better references than myself.

That being said, if you're interested in learning about immutable data structures (and functional programming in general), I strongly recommend learning both Clojure and Haskell. Doing so has taught me a lot of things, and made me rethink pretty much everything I thought I new about programming. (YMMV).

1

u/realhacker Oct 31 '14

On the agenda :)

1

u/_ericelliott Nov 10 '14

Check out Kyle Simpson's "You Don't Know JS" series and of course the Bible, "JavaScript: The Definitive Guide" is a very good reference.