Thanks for the downvote :)
This is really an argument against higher-level languages in general.
No, it's really, really not. It's an argument against deep home-grown abstractions when there are close approximations already available in the language or its community.
Hopefully you've had experience of a wide range of languages. Do you see a pattern in those languages, where, when the abstractions provided by the standard library are higher level, that libraries are generally more useful and the ecosystems are richer? When collections are in the standard library, libraries can communicate using these collections - but when they're not, every library chooses its own collections, sometimes using iterators, sometimes callback enumerations, sometimes linked lists, sometimes opaque handles, sometimes length-prefixed arrays, sometimes null-terminated arrays, etc.
This is what I mean by sociology. The more our code shares in common with other programmers, the richer our ecosystem is.
And the more our code diverges from other programmers, the more the ecosystem hurts.
Another word for "factoring" is compression. Taken to its limit, eliminating all duplication makes code indistinguishable from random noise. Human communication has redundancy and duplication for a reason.
Both Lisp and Smalltalk are able to implement 'if' as a library routine rather than a primitive. Their power to build abstractions is why I've lumped them together, not how they achieve their flexibility. How is irrelevant. Its the amount of rope they give programmers to grow their own little divergent gardens. It's how much they can encode their own idiosyncrasies - their common patterns - into their programs, and compress (aka factor) their code using those uniquely odd patterns.
I believe this rope is what prevented Lisp and Smalltalk both from becoming big successes. I suspect this rope is what might kill Ruby one day, but the amount of convergence and the extra coordination / speed of information spread from the modern web has already been enough to help it go far.
I think you've misread my statement as an argument against high-level languages, and are reacting to stuff I'm not writing.
I'm actually arguing against divergent development of home-grown abstractions when they don't have substantial wins above using what everyone else uses, even if what everyone else uses is worse - even if it's, say, 50% worse by some metric. It's also addressing the example in the original article, which is about creating your own class language in Javascript.
If Reg's class language took off, and became part of a generally accepted library - as common as jQuery or even CoffeeScript - it would be fine. But in isolation, used here and there, it's very much not worth it. And yes, I'm aware of the catch-22 here in adoption. That's the rough road every new language needs to travel, because that's basically what Reg is doing; building a new language.