You know, I have been reading a lot of interesting things lately.

Just read another post that was interesting to me. This article was about how Linux is bloated.

“Bloated? Linux?” Yeah, well, most modern software is bloated, and it is rather sad. Now, that having been said, he was talking about a distribution, but his point is extremely valid: Today’s programming “environment” is very much so bloated. Part of this is that we use languages that are expressive, duck-typed, and perform a lot of things behind the scenes for us. An example of that—as mentioned in the linked-to post—is Python. Python makes writing scripts and converters and other things very quick and easy, at the cost of increased memory and processor usage.

This isn’t a bad thing, per sé, but Python is used heavily in a lot of systems today for application software and system configuration utilities and things where it probably shouldn’t be used. It could be worse, but that’s no reason for things to be the way that they are presently. It seems that Python’s place in the system really ought to be to prototype nice ideas, and then, after the prototype is complete and accepted, re-written in a language such as C++ or even C#. (“C#‽ Isn’t that bloated, too?” Well, yes, but in a different way. C++ is good, though, if you need object-oriented things.)

There is a definite trend of moving away from compiled software, though. I am not sure if this is a good thing, or a bad thing. Of course, processors and the available memory of systems will increase as time moves forward, but why should base software be so hungry and depend on that? I remember when I was using a desktop that had 8 MB of RAM, a 66 MHz processor, and only 200 MB for storage, and I could do a great deal with it, and it was pretty snappy. Today, of course, I’d not be able to install a basic system into that space, and I shudder to think how (non!) responsive today’s GNOME would be on such a system.

What should the answer to this be? Is there a way that we can use software that is easy to develop, and not have the massive amounts of overhead that are often attributed to interpreted and byte-compiled software? How could we take advantage of that? After all, we have things like shared libraries that let us load an often-used library only once in system RAM, which should mean that we have decreased memory usage and increased performance, right? Well, sort of. But today lots of applications distribute their own, private copies of shared libraries for one reason or another, and so it makes it hard to determine how much an application’s real footprint in memory is.

So, the real question is this: With the availability of a runtime that can host (nearly) any language, and apparently is even able to host an operating system (anyone read about/tried Microsoft Singularity or SharpOS?), what about creating a Unix-like system using this technology, and making even more aggressive use of memory pooling between applications? Would this maybe be enough to combat the bloat that comes with extremely flexible and feature-rich programming languages and class libraries, maybe?

Or are we stuck moving forward into a world where the hardware and the software are both bigger than they used to be yesteryear?