[FoRK] Programming languages, operating systems, despair and anger

Jeff Bone jbone at place.org
Thu Nov 12 12:19:29 PST 2009

Benjamin writes:

> You have chosen a set of things you want available for creation of  
> one-liners, but I expect others would have different ideas of what  
> things are most important. If that were not the case, this problem  
> would be trivial.

*I* haven't chosen any such set of one-liners;  I'm merely pulling  
this stuff out of an existing set of e.g. Rebol one-liners and other  
one-liners, *assembled by (many, varied) others working in that  
language, which I do not.*  The point being, there is a large common  
subset of tasks frequently performed on data types that are now common  
but didn't exist 10 years ago, for which insufficient language- and  
environment-level support forces solutions in most languages to  
involve an unpleasantly-large amount of code at an uncomfortably-low  
level of abstraction, mostly resolving impedance mismatches between  
leaky and unnecessarily different levels of abstractions, data types,  
representations, and APIs.

I didn't come up with that set, nor do I suggest that it's  
authoritative or comprehensive.  But seriously:  go look at that list  
of Rebol one-liners again.  Then go look at the lists of any set of  
"one-liners", tiny hacks, etc. (in any such language that supports  
such things).  Arrange all these lists of one-liners by language  
according to language chronology, and see the evolution in abstraction  
over time.  Observe that, for the most part, things COMPLETELY stalled  
in terms of evolving language-level support for "new" data types and  
tasks about the same time the 'Net took off --- modulo Rebol and  
perhaps a few others.

I am tempted to conclude that *almost every* language designer starts  
with a relatively specialized beef with some existing language in some  
particular and self-absorbed usage scenario and then sets out to build  
a language that addresses *just that beef* in *just that use case* ---  
rather than actually attempting to take stock of the problems  
*actually, commonly* faced day-to-day in *using computers (and  
networks) to do interesting things.*

Others *do* have different ideas, no doubt.  I'm not suggesting any  
language should seek to be a silver bullet and tile the entire  
potential use-case space.  However there is *clearly* a *very large*  
set of present and anticipatable use-cases that could be covered much  
more adequately if only we acknowledged that (a) we live in a  
networked world, (b) you're not just using one box, much less sitting  
in front of a fucking TTY, anymore  and (c) there are several ---  
maybe couple-dozen --- data types *that we all use* (and operations on  
those) that, if we simply supported them better, would ease all our  
lives considerably.

What that list comprises is open for debate.  That such an  
intersection exists for a VAST amount of the programming that is done  
today *by anyone* --- is NOT.


More information about the FoRK mailing list