Keith Cirkel

The author addresses this issue directly in his follow up post [1]. He describes two ways to get watch functionality when using NPM as a build tool.

First, "most tools facilitate this option themselves - and usually are much more in tune with the intricacies of the files that should be listened for. For example Mocha has the -w option, as does Stylus, Node-Sass, Jade, Karma, and others." These options are simply invoked when the tool is called from NPM.

Second, "not all tools support this, and even when they do - you might want to compose multiple compile targets into one task which watches for changes and runs the whole set. There are tools that watch files and execute commands when files change, for example watch, onchange, dirwatch, or even nodemon."

[1] http://blog.keithcirkel.co.uk/how-to-use-npm-as-a-build-tool/

A little npm actually goes quite a long way:

https://www.keithcirkel.co.uk/how-to-use-npm-as-a-build-tool/

https://github.com/keithamus/npm-scripts-example

Although you should probably prefer yarn these days (concepts should mostly transfer over).

As for tranformations/transpiling/minifying... You could use webpack - it is popular, but quite complex. I've found this a decent introduction to understand how it works:

https://www.freecodecamp.org/news/creating-a-production-ready-webpack-4-config-from-scratch/

The good part about going that route, is that is quite explicit... You might get away with throwing out explicit in favour of convention - by using parcel instead:

https://github.com/parcel-bundler/parcel

(looks like gh readme is currently best entry point for 2.0 docs).

You can achieve some hacky form of operator overloading by implementing the “well-known” Symbol.toPrimitive, and exploiting the fact that the addition operator coerces its operands to either a Number or String.

It won’t be perfect but maybe you can do something useful with it. Symbols in general are a really powerful tool that almost enable meta-programming in JS. I searched “Symbol” in your repository and didn’t see any results, so if you aren’t familiar with them, I recommend taking the time to read up on how you can use them.

See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive#modifying_primitive_values_converted_from_an_object

And this 2015 blog: https://www.keithcirkel.co.uk/metaprogramming-in-es6-symbols/

https://www.keithcirkel.co.uk/whats-my-jnd/?r=AG4mKP____6_

"This shouldn't be possible. I'm not saying that you cheated, but not not saying that."

0.0011. The quote seems a bit hyperbolic. There were maybe 2-3 that I didn't see and missed. 1-2 that I didn't hit perfectly but close enough. Display probably affects results (but didn't change any settings for this). I have a Dell IPS. I also moved my head around a bit, felt natural while trying to discern the colors.

I do have a good vision (including color). Reminds me of the other color-game where you order some colored boxes to form a spectrum.

Edit: just tried hard mode and got 0.0084. Missed maybe 3 that I couldn't see. Usually some magenta or blue colored. Grey and red / brown seem to be the easiest.

Here is my list of solo developer blogs. Usually they are on topic. This does not include personal blogs I follow that happen to be developers.

@mdo (Bootstrop) - http://markdotto.com/

Keith Cirkel - https://www.keithcirkel.co.uk/

Coding – Corbin's Treehouse - https://www.corbinstreehouse.com/blog

Aaditya Purani – Ethical Hacker - https://aadityapurani.com/

Ben Balter - http://ben.balter.com/

fulldecent - https://privacylog.blogspot.com

Orange - http://blog.orange.tw/

Cocoa with Love - http://www.cocoawithlove.com/

Mark Otto - http://markdotto.com/

Moxie Marlinspike's Blog - http://www.thoughtcrime.org/blog/

hueniverse - http://hueniverse.com/

I'm a pretty heavy TS user and I was pondering the same thing. I've not been able to find a motive for allowing numbers as interface keys, but Symbols actually do make sense since, turns out (I'm always learning something new), you can use them as object keys in ES6: https://www.keithcirkel.co.uk/metaprogramming-in-es6-symbols/

That post outlines a few use cases which are admittedly outside of everyday JS/TS usage but I can see them as quite powerful when, for example, building frameworks and libraries that expose an API. I'd offer real-world examples of my own but I'm still working it out for myself .)