People will fill in gaps, so it depends on what gaps are left and how big they are.
What are methods and classes in a language like Java? Those are "roll your own constructs" as well.
In lisp code you can define your own functions and macros, yet the end still looks like lisp code.
Your argument is a common one, but it’s founded on a flawed premise: that Algol-language users know what they’re doing. Sure, they can read and write code written in that language, but how many of them actually understand the problem domain in which that software ostensibly solves problems. Truth is, a lot of programmers today are simply faking it: they don’t understand the business; what it does, why it does it, why it does it the way it does, and what the problems are that it has doing it. They know how to write code, and that’s all they know; or are interested in knowing.
For that type of programmer, rolling language constructs for the sake of rolling language constructs is simply a way to make themselves appear busy and productive without actually having to produce anything of value. Because to write useful code they’d have to learn the user’s business first—and that’s exactly what they want to avoid, because they hate having to learn stuff they’re not interested in and really don’t want to do it.
Take away the Lisp and give them an Algol; won’t make a blind bit of difference. They’ll still churn out the same endless makework, only this time it’ll be expressed as vast convoluted pointless class hierarchies and reams of autogenerated boilerplate. (You mention Rails: Worst Offender Ever.) Idiots will write useless code in any language.
Business accepts that type only because it doesn’t realize how bad it’s being scammed by them; which often as not is because the managers responsible for running that business are an absolute bunch of know-nothing bullshitters themselves.
..
The only people who will benefit from Lisp expressiveness are those who appreciate that the language itself and the code written in it is the least important part of the whole process. Because what they’re interested in is understanding and solving the users’ problems, and if they have in their toolkit the ability to construct a language that talks in the language of the business itself then so much the better for solving it.
You don’t have to be a great programmer to do this, and do it successfully too. (I’ve done it, and I’m a bear of very little brain.) You just need to understand the business itself; to get in the shoes of the folk who do those jobs day-in day-out and walk around in them till you see their world as they do. Once you can speak the language of that business well enough to “pass”, making a machine speak that language too is NBD. And once the machine speaks it, well, there you go. Cos that’s not a language that bangs two rocks together. That’s a language that lays a six-lane freeway in fresh-baked tarmacadam, all painted and ready to roll.
Code is not the product. Code is just tedious crap you have to wade through on your way to the product. As a developer, nothing pleases me more than not having to write code; or at least no more code than is absolutely unavoidable.
..
Those Nile links are good ones, I do recommend following them up. How to write a graphics pipeline in a hundred lines of code. Imagine if every program we wrote was like that, even programs that currently run to tens or hundreds of thousands of lines in those familiar “safe” Algol languages.
That’s what we should be shooting for in this profession, cos I dunno about you but I’d rather learn to read a hundred lines of code written in a custom language that’s tailored to that domain than 10,000 lines in a lowest-common-denominator crapfest like C++.
The work that Piumarta and Amelang et al did on STEPS is totally underrated. It has been quite sobering to watch these ideas go ignored by the larger community.
For the other truth is that most people just plain don’t like change, least of all radical change. And programmers are no exception. I mean, they may fancy themselves as brave pioneering visionary techno-utopians building this wonderful new world for everyone, but truth is most are so reactionary ultra-conservative they’d make your crazy John Bircher great uncle blush, and the only future they’re building for everyone else is the one that looks exactly like their own past. Because that’s where their comfort zone is, and that’s where they intend to keep it.
Me, I don’t have a comfort zone to preserve: I’m completely uncomfortable everywhere in life. But it is, at least, liberating. :)
--
“The reasonable man adapts himself to the world: the unreasonable one persists in trying to adapt the world to himself. Therefore all progress depends on the unreasonable man.” – George Bernard Shaw
That Nile/Gezira has languished is especially tough, but I think that's partially because Amelang had some personal troubles [1]. Note that at the bottom of that Github issue there is a link to a recent talk by Amelang in which, eventually, he talks about a new language he is working on called Bert or something. I'm thinking it's a next-gen follow up to Nile.
I mean, any one of FAANG alone could easily run a PARC or VPRI just off loose change in their kitchen kitty. And sure, it’s totally speculative blue-sky R&D that might [probably] never pan out; yet if no-one ever splurged on such gambles now and again we’d all be here having this argument by parchment and quill pen instead!
We learn by trying and failing, not by being afraid even to try. And in learning we succeed.
† lambda-the-ultimate.org
Spare me your smug condescension. Your position is founded on a flawed premise.
You're in the minority for a reason, and it's not because you're smarter (or because you "get it" or "understand what matters" or whatever). Lisp is not the one right way; it's the right way for some problems and some circumstances. And the same is true of C. Pick the right tool for the job, not because of a worship of one tool. C is more often closer to the right tool than Lisp. That's the reality that you're trying to ignore with your "C users don't understand" rationalization.
Now, if you wanted to argue that C is overused, that in some circumstances where C is chosen Lisp would be a better choice, that would be a reasonable argument. But "C users just don't understand what matters"? BS. You need to get over your blindness.
And then you blame the users for “not speccing the job right” when they discover your “solution” not only fails to make their lives any better but often makes it even worse. I’ve worked a decade professionally as a user-turned-developer, so please don’t say this attitude isn’t cultural right down to the bone. I’ve seen it, I’ve dealt with it, I’ve walked out because of it. And looking around me that seems pretty much par for the course.
This is why I like a philosophy of reshaping your stock language into something that much better expresses the business concepts and processes you’re dealing with, then writing your solution in that. It forces you to learn the user’s job before you get underway, because you can’t fake understanding: your new “business language” either does the job or it sucks.
Building up that vocabulary is the first test of whether or not you understand what you’re doing; and until it proves you do you’ve no business proceeding or you’re just wasting everyone’s time (including your own), and giving this industry an even worse reputation for shafting the customer by giving them shit than it already possesses.
--
† Ironically for exactly the reasons I’m talking about: you’re unable to see anything that isn’t about coding. But the code is the least significant part of the overall puzzle; and until you understand the puzzle in its entirety you’re not fit to solve any of it.
TL;DR: I may be nuts, but I ain’t what’s broken.
But I think you're overselling Lisp in this context. The kind of programmer you're talking about, given Lisp, won't develop a "business language" that matches the user needs. They will at best just develop a language that matches the product manager's feature request description, and at worst they'll just start hacking away in Lisp without developing any vocabulary at all.
And I think you're misreading where I'm coming from. I can see a lot more than just the code. I totally get that delivering what the user needs is what counts. Just one example: In a hallway conversation, I said we should do X instead of Y because it would be better for the users. The better part of a decade later, I got reminded of that hallway conversation, because it turned out that a litigation-happy competitor had patented Y, and in a court case wanted to apply that patent against us, but couldn't because we didn't actually do Y. I said that the attorneys should say that, if our competitor had patented delivering a worse user experience, they were welcome to the patent on it.