Downwardly Scalable Languages

I have written some musings that I may keep growing into more of an article, but I thought I'd link to it here:
A lot of thought has been dedicated to scalability in computer systems. However, outside of the embedded systems arena, most of this effort has gone into making systems ever larger and faster.
For a change, let's have a look at downwardly scalable systems - systems that work well where resources are not abundant. Going beyond considering systems that don't place hefty requirements on the hardware (CPU, disk, memory, bandwidth), we wish to consider "human resources" - people, and the effects that downwardly scalable systems have on development.

I'm still mulling the subject over in my head, but I like the concept a lot.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.


I think this approach is one of Lua's big selling points, both in terms of resource requirements and human factors. As you say, it seems to be a relatively neglected niche. What other languages out there adopt this perspective?


Well, Forth, obviously. This has always been the Forth niche.

Hardware vs People

Forth 'scales down' very, very well in terms of hardware, but I don't think it scales down so much in terms of people. Or if it does, it doesn't scale up *at all* because you're always trying to keep track of the damned stack:-) At least that was my experience. It's certainly a very cool language, that ought to be at least played with to get a feel for its theory of operations.


I'm told that if you can't see what's going on in your words, you probably should refactor. I guess it's a bit like with rpn: I'm not going to gratuitously store temporary results on the stack when I can use them now.

Langugages or libraries

David, I find that a lot of the points you bring up relate more to what libraries a language has rather than the language itself. I find this to be very common when discussing the pros and cons of programming languages.

I'm not saying that libraries are not important. On the contrary, they can make up for a badly designed language. But I think it is important to be aware of if one is speaking about the language or the libraries that are available.

Anyway, I find the idea of downwards scalable languages interesting. They are worth pondering upon.



The title is about scalable 'systems'. Maybe that's a bit too vague, but it captures part of what I was thinking about. You are correct - libraries are certainly part of that, maybe even more important than syntax/look/feel.

But the central idea is still there. Consider doing sockets in C as opposed to Tcl where you just do set sk [socket 80]. You can still fiddle with it by configuring it, but it does the obvious thing easily. Of course, in C you could also do something like int opensocket(char *hostname, int port). It would still feel just a bit clunkier though due to the types and syntax, so I think both syntax and libraries are important.

Of course, to scale up again, you've got to make sure that doing non-obvious things - things the author hadn't thought of - are still possible, and hopefully just as easy. An easy-to-use straightjacket isn't what we're after:-)

What makes PHP "accessible"?

Is PHP really that much easier to learn than, say, (a-dynamically-generated-html-content-related-subset-of) Scheme?

As a language...

...probably not as accessible as some things out there.

As a way to create dynamic web pages, it's very immediate compared to, say, the J2EE "stack" (pile?). I suppose I should say that in the article.

I'm not going to get started on scheme vs other languages, though. If you have a good example of a scheme system that is used by non comp-sci people and that 'scales down', it would be interesting to see how it was done, though, and what the user experience is like.

I dunno, though

As a way to create dynamic web pages, it's very immediate compared to, say, the J2EE "stack" (pile?)

If you have Tomcat set up, you can knock together a quick JSP page without too much hassle. Old-style ASP, horrible as it was, was pretty quick and easy to get into.

The point with Scheme (and Haskell too, actually) is that you could define a friendly subset of the language for end-users. There's some stuff in PLT Scheme that makes creating web pages very straightforward.

Genetic Code?

The genetic code may qualify as "scalable" - although it would be good to first strictly define that term.

Josef Svenningsson's remarks about "Languages or libraries" seems particularly relevant when speaking of the genetic code. In particular what are the analogs of

  • the CPU,
  • the instruction set,
  • a unit of memory,
  • libraries,
  • I/O?

And questions come to mind, e.g., as can we define a "minimal system" that can reproduce (given some external environment)?

The genetic code/language/CPU/system is one of the most important language puzzles facing us today and a worthy challenge with very high possible payoffs in fame, money and personal satisfaction.