var wrap = require('ansi-wrap');
    
    module.exports = function red(message) {
      return wrap(31, 39, message);
    };

    module.exports = function(a, b, msg) {
      return '\u001b['+ a + 'm' + msg + '\u001b[' + b + 'm';
    };

In the defense of javascript, dead code elimination is kind of hard because it is such a dynamic/messy language and that kind of pushes people in the direction of ridiculously fine-grained modularization. Languages with an actual type system and compiler tend to produce artifacts that only include code that is actually needed. That requires dead code elimination that actually works. Beyond what comes with the browser, there isn't much of a standard library. That's for the same reason. You'd either end up shipping the whole thing on every website or depending on some convoluted tooling in an attempt to strip it down to what you are actually using. Minification is of course a thing but it usually boils down to more obfuscating than actually removing dead code.

My strategy is to generally avoid the whole ecosystem as much as I can. I've been using Kotlin-js lately. Great libraries, runs in a browser, reactive styled components using fritz-2, web compose, or if you really insist react. You still get exposed to some of the madness (like webpack breaking between minor releases) but mostly you are shielded from that.

Is there a site or code snippet where I can see which of the popular dependants was fooled into using this crap and is driving most of the downloads?

> Lightweight - Only one dependency, the excellent ansi-colors by Brian Woodward.

s/projects/functions

e.g: [1, "one", true, false, 0, "zero", null, undefined]

edit: also ["1", "0", etc]

edit 2: also [NaN]

Another way to look at this is that a lower-paid SWE is paying for their mental health and morale. In my books, that's a winner :)

With the assumption that those engineers whose high/er salary in big/ger companies is not achived through mastery (Netflix is certainly not going to hire the Jon Schlinkerts), they're likely going to work with, say, "moral peers", which is typically undesirable for mentally healthy people.

...but interviewers often assume that they are all useful packages and that the numbers are not inflated.

You mean how broken it is, and how to take advantage of it? Depending on your business they could fit in really well.

    isEven(0);
    //=> true
    isEven('1');
    //=> false
    isEven(2);
    //=> true
    isEven('3');
    //=> false

There is a bit of a culture clash inside Javascript. Even when you're a veteran contributor, sometimes maintainers resist changing packages, as simple as they are, because there is an implicit assumption that popular packages, or even packages with too many dependencies are "better" or "handled all the edge cases".

Even with careful evaluation of the options and a write-down of issues and a proper comparison, you need ten times as much energy to remove a package than it took to add it.

It's even worse is when "too many packages" is in the DNA of the package you're collaborating.

  'use strict';

  module.exports = function(num) {
    if (typeof num === 'number') {
      return num - num === 0;
    }
    if (typeof num === 'string' && num.trim() !== '') {
      return Number.isFinite ? Number.isFinite(+num) : 
        isFinite(+num);
    }
    return false;
  };

  var isOdd = require("is-odd");

  console.log(isOdd([1])); // TRUE!!

    function isOdd(i) {
      return i > 0 && isEven(i - 1);
    }

    function isEven(i) {
      return i == 0 || isOdd(i - 1);
    }

https://www.npmjs.com/package/is-even-cyclic has a cyclic dependency with https://www.npmjs.com/package/is-odd-cyclic.

Several of these utility and helper packages are then pulled into other packages and build tools and marketed as legitimate packages, effectively hiding and masking the "just a demo" labels of the root is-even, is-odd, is-number packages. When people like myself complain about the absurdity of NPM supply chain verification, this is what we're arguing against.

redirects to

https://github.com/i-voted-for-trump/is-even

Does saying dang 3 times work?

https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how...

Stupid debates over a formatting tool - or in this case, a simple conditional - should tell you that something is seriously FUBAR in Javascriptland.

The "current programming environment" is the problem, and it doesn't exist because Javascript is superior to other languages, and should be used everywhere, but only because web developers are easier to find and cheaper to hire.

And in any case, you could ship a "standard library" for javascript that covers most common use cases in a single static file. We used to do that, it was called JQuery. Even assuming for the sake of argument that Javascript's standard library is lacking, that doesn't justify the mess that is Node's micropackages.

Because it's consensus-driven, and that consensus is achieved on meetings organized every ~3 months.

And because of strict backwards compatibility rule, everyone is extremely cautious.

I tried to add new methods to Set, but proposal is basically being held hostage by subclassing proposal. https://github.com/tc39/proposal-set-methods