In the past 10 years, people who build software and the tools that they use to build this software have gone from one extreme to another.
Years ago, software development was mostly about squeezing more program material into a tighter space. Developers would go to extremes to get a couple of more program instructions into the same or smaller space. The speed of the program was a distant second to compactness.
As the years past and computers became faster and hardware became less expensive, there has been a major shift in the way that programs are developed. Even the tools used to develop programs have undergone this shift. We have gone from anything for compactness to anything for speed.
The net result of this development shift is that the size of programs has gone up dramatically to the point where it has become absurd. When I speak of size, I am referring to size in bytes of the application as well as the amount of memory the application consumes. We now have language compilers that require half a gigabyte of disk space, web browsers that require us to download 40-50 megabytes of compressed data.
It is understood that hardware including disk space and RAM is much less expensive than it used to be. This is the primary reason why software has become bloated. Most developers are under the impression that the size of an application is a resource issue that needs to be addressed by adding more hardware. The main problem with this line of reasoning is that it causes a chain reaction. As computers become faster with more RAM and disk space, these bloated applications are consuming the excess. This is why a newer, faster computers do not feel significantly faster.
The problem is compounded by the fact that the compiler vendors are using bloated techniques to create bloated language development tools which developers use to produce even more bloated software. I am not suggesting that all compiler vendors are causing this problem nor am I suggesting that all developers perpetuate the problem. I am saying that this situation happens in most cases.
What we, as developers, need to do is to periodically perform a sanity check. As a developer, you should not give in to these tactics. Do not accept that all tools are like this. As a consumer of software, do not accept any software that has unrealistic requirements. Send a message to compiler vendors and software companies that produce overly bloated material. The best message you can send is to not buy or use software that has unrealistic demands.
To put things into perspective, I will now discuss what I believe to be the best example of lean software. QNX Software has an operating system similar to Unix that is not monolithic and does not require a lot of memory to run. A while ago, QNX Software decided to demonstrate exactly how compact their OS and applications were. They build a demonstration product using IAT which stands for Internet Appliance Toolkit. It is aimed at embeded Internet appliances. QNX Software constructed a demonstration loader consisting of the following pieces:
The most amazing part of this demonstration product is the fact that all the pieces together fit onto one 1.44mb floppy together with a boot loader. That's right. You are not seeing things. As a matter of fact, after the OS has booted, you may remove the floppy. QNX Software calls this demonstration the Web Challenge and I would say that this easily beats anything I have encountered in terms of compactness.
I guess you can understand why QNX is my favorite OS.