9 ms·
Deep JavaScript: Theory and Techniques
- jorangreef 6y agoOne of the things I love about JavaScript is that you can write an almost 10x faster hash table than the standard library if you take care of cache misses and GC: https://github.com/ronomon/hash-table#motivation https://github.com/ronomon/hash-table#motivation In fact, all the usual low-level optimization techniques like reducing branch mispredictions and expensive memory accesses apply, and make a huge difference, even though you're writing in a high-level language.
- zamalek 6y agoIt's why managed languages have such a bad rap: people think that this stuff ceases to matter. I remember the C# DirectX billboard sample, it was something like 10x slower than the same C++ sample in the same version of the SDK. Why? C# didn't have generics yet, and a value type was being stored in a non-generic list. Something like 4MB of memory was being copied around due to boxing and unboxing. These things always matter.
- _bxg1 6y ago*for a very specific use-case where you have an ungodly amount of data to insert Still, it's interesting that there is something to be gained under these circumstances. I'm typically skeptical of this sort of thing because the standard library is written in C++. One time I thought I was very clever and hand-wrote a more appropriate sorting algorithm for a specific use-case only to discover that, no, Array.sort() was still faster by sheer brute force.
- austincheney 6y agoThe algorithm for Array.sort is implementation specific, but there is an ECMAScript proposal for a standard algorithm.
- jorangreef 6y agoWe actually wrote the original version in C with SIMD extensions as a Node.js binding, but the JavaScript version was still twice as fast. I kid you not. You will find the reason for this in the README, it's the last bullet point under "Fast": https://github.com/ronomon/hash-table#fast https://github.com/ronomon/hash-table#fast
- _bxg1 6y agoHuh. Does that apply to WASM too or just to binding from Node?
- jorangreef 6y agoI am not sure but I wouldn't think so, unless you have to serialize/deserialize or otherwise transform or inspect function call arguments in some or other way, as you need to do when binding JavaScript with C.
- game_the0ry 6y agoI do appreciate the effort the author put into that library and obviously performance is important. However, JS doesn't primarily live in the server side world, it mostly lives in the browser world. And in the browsers, you rarely do heavy processing. If you are, you're doing it wrong - that logic needs to live on the server. You're also doing it wrong in you are relying on server side NodeJS for tasks that involve heavy duty computations. Still, interesting to know. I wonder if the author can make this repo a proposal to the TC39 committee.
- ralphc 6y agoOne of the selling points of tensorflow.js is that you do your processing on the client, for privacy reasons. This is heavy, heavy processing, and you're doing it right.
- _bxg1 6y ago> And in the browsers, you rarely do heavy processing. If you are, you're doing it wrong - that logic needs to live on the server. This is very incorrect. At my last company we had a React interface (a specialized IDE, really) that needed to juggle (sort, filter, process) and work with sometimes hundreds of thousands of entities at once, all in-memory. JavaScript did this just fine, and the user experience (and the API design) really benefitted from not having a bunch of extra round-trips to the server. Even in this extreme use-case, the bottleneck was always the few-hundred items that were actually rendered in the DOM at a time. We virtually never had performance problems from sheer volume of underlying data.
- game_the0ry 6y ago> At my last company we had a React interface (a specialized IDE, really) that needed to juggle (sort, filter, process) and work with sometimes hundreds of thousands of entities at once, all in-memory. The author's example inserts 4M elements. > and the user experience (and the API design) really benefitted from not having a bunch of extra round-trips to the server. Possibly, but unless you benchmarked both scenarios, this might not be the case. Performance over networked devices often has trade offs, sometimes those trade offs are directly contradictory, eg sorting/filtering/mapping/etc data on client side versus server side via api call - sometimes one is better than the other but you wont wont know unless you benchmark. I get the impression that your company did not go through that exercise, considering you guys are building an IDE with scripting language.[1] [1] https://nickjanetakis.com/blog/switching-to-vscode-from-sublime-text#:~:text=Performance,an%20i5%203.2GHz%20CPU.&text=CTRL%2BP%20searching%20is%20slightly,or%20getting%20in%20the%20way https://nickjanetakis.com/blog/switching-to-vscode-from-subl....
- seph-reed 6y agoI just think this is interesting. The following statement is true: `(~~4.2 === 4) && (~~-3.5 === -3)`
- XCSme 6y agoIsn't `true` the expected result? Apart from that, who would write code like this?
- ipnon 6y agoAntagonistic JavaScript code golfers typically are not JavaScript users, I've found. edit: It's like writing an intentional buffer overflow in C. You don't see it as often because it requires actually knowing how to program.
- XCSme 6y agoThe thing is, the result above is not even specific to JavaScript (in PHP for example it also returns `true`), and it makes a lot of sense if you know what the bitwise operators do.
- mrspeaker 6y agoNow I'm curious what result the OP was expecting... that's how bitwise NOT should work on (IEEE 754) floating-point numbers regardless of the language, isn't it? (4.2).toString(2); > "100.00110011001100110011001100110011001100110011001101" (~4.2).toString(2); > "-101" (~~4.2).toString(2); > "100" Perhaps the initial NOT is supposed to maintain the bits after the point? I have to go look at the spec. [Ok, looks like that not defined in the spec, and is a language-specific behavior: I have some homework now!]
- XCSme 6y agoI think in C++ for example you can't even pass a floating number to the bitwise not operator.
- seph-reed 6y ago
- ipnon 6y agoI've never heard of object sealing or freezing, glancing at the Table of Contents. JavaScript keeps surprising me. // Levels of protection: preventing extensions, sealing, freezing Object.preventExtensions(obj) Object.seal(obj) Object.freeze(obj)
- DylanSp 6y agoFrom using immer[1], I learned about Object.freeze(), which immer uses under the hood. [1] https://github.com/immerjs/immer https://github.com/immerjs/immer
- cjones26 6y agoThough I recommend to my team to avoid mutation if at all possible, there are times which I have found immer absolutely invaluable. Try spreading out an object 15 levels deep to replace a single property value and you'll catch my drift.
- acidbaseextract 6y agoMy biggest challenge with immer has been that my code aesthetic taste leans functional, but immer makes code look imperative even if it is ultimately functional. Always looks a little wrong to my eye!
- wereHamster 6y agoWriting old-style pure code to do changes in a deeply nested structure is cumbersome, both to write and read. Eventually every language will find nicer ways to allow programmers to express these mutations. JavaScript doesn't provide a nice way to extend the language syntax, unlike some other programming languages. So most DSLs end up looking like imperative code but do pure mutations underneath. I understand, for the reader it's confusing, because unless you know that it's a DSL you never know whether the mutations are pure or not. Compare that with Haskell, with its support for custom operators, allows for some quite succinct code to express deep mutations (cf. lens library)
- adamc 6y agoDisappointed not to see a dead-tree version.
- tempodox 6y agoThis looks like it's worth a place in an electronic bookshelf. Among other things, following a link in the contents led me to this little pearl: https://mathiasbynens.be/notes/globalthis https://mathiasbynens.be/notes/globalthis
- ezequiel-garzon 6y agoHe’s great! Consider https://mothereff.in/ampersands https://mothereff.in/ampersands
- jacobr 6y agoThat’s horrific and amazing
- MatekCopatek 6y agoLove this! Some languages are typically taught in introductory programming courses - it's a very deliberate process aimed at explaining concepts from the ground up. JS is the opposite, people mostly learn it top-down, doing web development and being forced to use it. And like eager college graduates need to learn it's sometimes a waste of time to optimize an algorithm, DIY JS devs can greatly benefit from a bit of theory and technical depth. Resources like this are perfect for that. I can also wholeheartedly recommend Kyle Simpson's You Don't Know JS.
- azangru 6y agoHave you seen that Flanagan's JavaScript the Definitive Guide, the famously big book with the rhinoceros on its cover, has recently seen a new edition? I wonder how deep its JavaScript goes :-) (https://www.amazon.co.uk/JavaScript-Definitive-Guide-David-Flanagan/dp/1491952024 https://www.amazon.co.uk/JavaScript-Definitive-Guide-David-F...)
- petercooper 6y agoDavid has written about what's new, if anyone's interested: https://davidflanagan.com/2020/05/03/changes-in-the-seventh-edition.html https://davidflanagan.com/2020/05/03/changes-in-the-seventh-... I also (briefly) interviewed him about it here: https://superhighway.dev/david-flanagan-interview https://superhighway.dev/david-flanagan-interview
- ithrow 6y agoNo PDF version?
- jmchuster 6y agoI've always enjoyed the famously small book "Javascript: The Good Parts", albeit a bit dated at this point
- mayank 6y agoUnfortunately, the language has changed so much in recent years that I wouldn’t necessarily recommend that book anymore. A large number of fundamental features have been introduced since 2008, including async/await, lambda functions, class and extends syntax, proxies, and a ton of builtin methods like map() and forEach() on native list types.
- jmchuster 6y agoFor sure, these were the old days before jQuery was even considered a standard library. It was still duking it out with YUI and Prototype.
- divbzero 6y agoA few bits of deep JavaScript that I’ve learned from Deep JavaScript: – The % operator calculates the remainder, not the modulus, which makes difference for negative numbers. – Constructors can return a Promise. – Function names are stored as the .name property.