Software Development

Going back to commerce, how exactly is specialisation done? Well, we have food industry, clothing, hardware technology sector, space industry, transportation, etc. Each one of these has further specialisation. Once the basic necessities have been taken care of, specialisation enables one to produce entertainment products and services. When creativity enters the scene, then you have something of true worth because the entire system grows and starts to have a life of its own.

There is something here that is never spoken about. It'd be too obvious. Everything has a common interface. Every sector of commerce is geared toward producing something for human consumption. For sure there are secondary types of specialisation like computer or auto parts. But think about it. Having a human as the primary interface gives a starting point for anything that gets done. No matter what is done, eventually a human will use it directly or indirectly. If we don't, it doesn't matter because no human has even seen it. That's the obvious part.

One point of all this is that the interface never changes. It's always the same. Cars and all their parts have been standardised. Roads. Houses too. Computer parts even. Clothing. Music. Everything has some kind of standard technique or process. There can be variety, but only by staying within the standard.

When writing software, the same thing should apply. We should be writing software for humans. But we don't. No. We write software for input devices. We write it for the secondary interfaces. But these aren't standardised. Sure, right now we have the screen, keyboard and mouse. The only problem is that these things change over time. Some people use trackballs. Some people use touch screens. Some have other devices too. Anyways, there's always a layer in between our software and the users. So let's assume that we only use the screen, mouse and keyboard. Still doesn't simplify things because we have yet another layer called the OS in between. Then the GUI. And finally, we have the programming language.

Outside of programming, we have rules on how things should interact. When we drive, we must learn beforehand the rules of the road. Over time, the rules start to converge and soon you have one single global set of rules or something close to it. The only differences are a few islands that drive on the other side. Note that these islands were not directly connected to the rest of the world and so were able to evolve in their own manner. Now compare that with how we write software. Hardly any two pieces of software talk to each other. I'm talking about executables. Shipped working applications. While plugins do exist, it's not on the same level. They are not on equal footing. Two cars on the road have the same rights. They interact on an equal basis... that is until there's an accident.

And here's a further point. Because each application is a universe onto itself, there is not much consideration about external software. The outsiders must adapt to you and never the other way around. And there's no global communication network or set of rules that evolves on how applications should talk to each other. More to the point, programming languages have their own rules that are completely irrelevant to the final products. Actually, many languages do support FFI, but that seems to be the extent of it.

It goes so much deeper than any of this. Unfortunately, I can't bring it up without sounding like a CD that skips. I'll see if I can't just skim the surface. Rules that enable specialisation must allow every entity to be on equal footing. This is different than everyone being allowed to do the same thing. Equal footing and being able to do the same are world's apart. Here's an example. I can hire someone to run errands for me. Everyone can hire someone to do the same. Even the person I hired can subcontract someone else. But it's not equal footing. It's hard to differentiate because of the way capitalism works. Just remember that paying someone to do a task is not what makes specialisation work. Specialisation is an understanding that everyone does a task in exchange for certain other goods and services. You don't need money to make this happen. Where money is useful is for the exchanging of these goods and services so that leechers don't ruin everything and also to control limited supply of certain items. In any case, note the two-way interaction that goes on here that doesn't happen when you pay someone to do work. Delegation is the anti-thesis of a well balanced system because money only flows one direction and services in the other. One is a make believe item with no real intrinsic value (money) compared to real work. What this does is cause one party to be a subject of the other. This is why I believe the entire way we construct software is flawed at its very core. While some parts can be built this way, the entire system cannot. And that's sadly exactly what we have today except for P2P and the Internet (without the web and other services). And just to clarify... in the real world, the person I hire can buy stuff with the money paid so an even exchange can be accomplished indirectly. In programming, there has to be a long list of suckers at the bottom.

Pretty much everywhere you look, things evolve into more specialised versions of itself. I believe that if something has existed for a certain number of years and you don't see a convergence, then it's being done incorrectly.

In Fred Brooks' paper No Silver Bullet, he says:

[...]no inventions that will do for software productivity, reliability, and simplicity what electronics, transistors, and large-scale integration did for computer hardware.

What I find strange is that there's nothing in software that makes it unable to replicate the features of hardware. I really do hate that paper. It's the most evil paper ever written about software development. I say "evil" because it has caused unnecessary damage to the field of computing and has been proven wrong time and again yet people still quote it as fact today. Software development is not limited to functions. That there is no silver bullet may be a property of the current failing system, but not of software development in general.

As a shocker, many (most?) programmers do not like hardware. These programmers cringe at the notion of creating software in the same manner as hardware. Is it the level of specialisation and knowledge that goes into it that is bothersome? I don't know. But it does show how hardware has evolved and converged. It also shows how specialised it has gotten. While software need not replicate hardware 100%, there is something to be said about how these parts connect together. They all follow the same rules. And when they don't, there's a way to convert the signals. Programming could learn a lot from this.

Ever notice how a human can use the features of an application, but if I want my own software to use it, it's usually impossible? That's my earlier point about programming for input devices. If applications were independent items that could be connected to other applications with all their features accessible, then we'd see incredible leaps in productivity. Unfortunately, companies don't want others to use their features. They want the user and only the user to use them. That's one reason why we're still in the current state. Hardware has a nice feature that if you want to use certain functionality, you have to buy it or manufacture it yourself. You can't leech. In software, you must leech. And that, right there, is the punch line. We need to come up with a system where leeching is allowed. A system where there's specialisation without having something like money as the equalizer. You can't pay a function in exchange for its execution. It makes no sense.

And I'll say it again that I think this is the perfect opportunity for OSS to really flourish. It's the only mindset that really enables a true solution. The disappointing part is that OSS is mostly concerned with reproducing existing tools and applications. While that's fine in itself, it does not do anything toward developer productivity.

We need a system where any code can be added on. Where this code can execute of its own volition as can all others at any time. Where there is a consistent mechanism for connecting different code. Only then will we see an improvement in productivity. But it won't solve the issue that it seems to contradict common business sense, yet OSS has proven that it is possible. Now, we just have to look in areas that others do not want to look.