The world of software is changing. Whether this change is for the good or the bad is neither here nor there, it is happening. For once this change is being pursued by the end user, rather than being dictated by the software companies. Software is moving towards open systems.
In the 50's and 60's, mainframe computers and batch processing were the order of the day. They were used by large companies, as only large companies could afford to run them, to process lots of figures. The problem with these systems was that the only software thyese machines could run was the software of the machines creator. For instance, if a company owned an IBM mainframe they had to use IBM software. This meant that they had to rely on the manufacturer to provide an adequate auite of software, and provide enough functionality in each piece of software.
When in the late 1970's, the first personal computers were released a different state of affiars presented itself. Due to the fact that many of these microcomputers, as they were called due to their size, were developed by small companies, they couldn't afford to develop their own software, so third party software developers were called in. One of the most productive third party devlopers of the time were the now infamous Microsoft, formed by Bill Gates and Paul Allen in 1975. This led to competition amound developers which ultimately produced the current situation in software development.
There are problems with this approach though, which is why, as the opening statement said, the software industry is changing. That change is towards open systems.
To maybe show some of the benefits of this, one can look at the computer hardware industry as an example. As previously stated during the 1970's the first personal computers started to appear. The internal hardware of each was different. As time passed by different machines fell by the wayside, and new machines appeared. Eventually a few machines started to gain dominance. This was due to a number of reasons. These machines were the IBM PC, and the Apple II, and latter the Apple Machintosh. The reasons for this dominance in the case of the Apple computers were the superior user interface, and the software available for the system. This software was mainly used for desk top processing and computer art, hence although having a large user base, the Apple computers remained a niche product. The reasons the IBM PC became dominant though were different. They weren't because the IBM PC was technically superior to the other microcomputers, but because it only used standard parts and price. This use of standard parts enabled other manufactuers to make IBM PC clones, which drove the price down due to competition. These clones were compataible, although often not 100%, with the IBM PC.
This allowed software developers to concentrate on one platform, the most successful one, which resulted in cutting costs, and further devlopment. This resulted in a catch 22 situation, and is one reason the IBM PC compatible triumphed. Users wanted the software, hence the bought the machine with that software. If a new computer computer it wasn't supported by users because it didn't have the software, or software devlopers because it didn't have the users.
Since the PC first gained market doiminance, due to a vareity of standards being introduced a whole industry has evolved to offer this one platform all many of different peripherals. The advantages of this approach are that, if any graphics card should work with any PC, along as the interfaces are the same for instance. So if something breaks, or somebody offers a similar product cheaper, the user can switch products.
This is the type of situation that many people are striving for in the software industry. Depending on how far this standardisation went, different benefits would present themselves. Currently there are numerous standards trying to become the industry standard, as it were. For instance, there is OpenGL for 3D graphics. This was defined by a group of software devlopers, including Microsoft and Sun Microsystems. There is also POSIX, a standard interface to windowing graphical user interfaces.
If these standards do actually migrate into wide sread use, they will provide large benefits. For example if a person is working in one department of a company, and either gets move to another department, or even another company, they will alredy have experience with the standard software, used for their position. This will result in that person not needing to be retrained, and hence will save time, and money.
Although these benefits are worthwhile, it would be better if the software companies could go further and standardize to an even greater detail. For instance, say companies A & B market a word processing package. Currently the user is given the choice of using either the entirety of one or the other. Now say that each piece of software was based on a standard modular interface. Then the user would be able to buy the main word processing engine from company A, because it might have a quicker reformatting algorithm, and a spell-checker and a thesaurus from company B, because they have more words in them. This sort of interconnection between software is possible, with current software engineering techniques.
The only flaw in this plan is the companies themselves. This is the one of the same problems with developing standards. When companies meet to decide on an industry standard, due to the competitive nature of the industry, each company is going to want the best possible deal for themselves. This means often desicisions are hard to reach, because one company wants to do something one way, while another wants it done a different way.
Software is changing, for the better as the writer thinks. Because with the standardisation it means companies don't have to rely one software company and hence provides a more reliable system, and increased competition, which will hopefully bring prices down, and maybe let smaller companies enter the fray. Let's just hope standardisation does for the software industry, what it did for the hardware industry, provide more reliable, more techinally superior systems.