What do simple programming languages offer? They're cute, and their simplicity is enough reason for their existence. Simplicity is the universal virtue, but the word has been abused to meaninglessness.
The simple languages I am referring to, which are universally small in some sense, are the likes of Lisp, Forth and C. You can comprehend them, utilize them and implement them. By you, I don't mean a group of a thousand people, but rather the humble individual equipped with a laptop. Modulo spec correctness, it's conceivable to implement a useful mimicry of these languages. More so now than ever. Yet, they aren't mainstream. It's the bells-and-whistles class of languages that are mainstream. But, then again, I should retract my complaint since those languages do serve a purpose. They give you something instead of an abstract system that allows you to make anything you want. The saying goes, "People don't want a drill, they want a hole in the wall."
Much can be said about how similar systems tend to have the same fate. I, however, am not here to lament their losses. I started off this post to talk about another reason why small languages matter: to rid the world of ecosystems.
You hear it in the sales pitch of any popular programming language. "It's got a rich ecosystem." "You can find a package for anything." "There's a ton of people working on it." "It's got great platform support." How commercial. How depressing that we need to support multiple systems instead of this being a non-issue by some mystical brilliant miraculous way in which we had decided to construct our world in the first place. How depressing that a programming language needs a gazillion people working on it to remain useful. Why can't we just have simple things? You see, if you need a load of people to make a programming language, it will unfortunately be suited to the needs of the average than the specific: you. Sure, you'll get some mileage out of it, but it won't be perfect.
Some people don't care. They aren't bothered in the very least by this. I am one of the few who gets neurotic about a certain expressive capability being limited by the design of a language. And my biggest sadness is that I can't just implement a C on a whim. Even if I managed to do so, I'd need to implement a whole set of libraries, which is just glue code on top of abstraction layers and undefined behavior and specs behind pay walls.
Look, all I'm saying is that we should have lauded small languages. We should have slowed down and noticed the red flag in ideas like "platform support" and "language ecosystem." It should have been viable, and natural for a programming language, environment, system or what have you to be created on a whim by a single programmer without much effort. We have machines that can compute a billion things at the same time and under a second people. Why are we, then, so limited?
My love for Forth, although I fail to precisely elucidate it time and time again, can be captured in one angle through this way: A capable version of it—more capable than most popular languages today—can be implemented for any machine at a whim.
You can understand Forth bottom to top. You can entirely comprehend it. You will struggle at first, most probably. But then it will all be clear, and so will it's inevitability.
Such is the beauty of LISP. It's the measured set of features and their interplay. And with C, it's the brutality. It's when you want a low level compiled language with some conditionals, loops, and procedures. There's not much to it, and that's exactly what it is that's so great.
I wish the announcements of new programming languages didn't have to be endowed with explanations of the necessity of their existence, or acknowledgments of the exuberant ambitions of their creators. I wish you could just create a programming language, or a computing environment or anything like that and it would be something commonplace and simple. I wish we did interplay between software components better in the first place.