A future without C++?

Clearly, this couldn't happen, because we already have C++! So, this isn't much of a peek into the future.. except, that things didn't have to turn out this way. Due to an accident of history, it is quite easy to show how C++ could have effectively never been standardised. Now, for a lot of people, the loss of C++ would have been no bad thing, but the fact is that C++ is an extremely popular programming language and is responsible for a lot of the popularity of modern day object-oriented programming systems.

Where C++ came from

C++, as many people know, was developed by Bjarne Stroustrup, who was working for AT&T at the time. AT&T was actually one of the biggest users of software, certainly in the 70s/80s. Although development on C++ started in 1979, it wasn't really until 1983 that it began to take shape (and it's modern name - previously, it was called C with Classes).

The initial version of C++ released used a compiler called CFront, because it was more or less a front end to C: although the new language was a descendant of the C language, it was different and incompatible. A front-end was written to translate the new language into C, from where it was compiled. So, essentially, C++ as it was then was simply a set of extensions to C designed to make programming easier.

Now, at this time - mid-eighties - as the language was becoming more popular, patenting software was not so popular: even the US only allowed patenting of software in certain circumstances. C++ was not patented, and wasn't seen as a product in itself; more as a tool designed such that it would be used to create products.

These days, this decision would be different. It would be seen as part of the company's "intellectual property", something of marketable value, and would be protected with all the methods available to the company - including, in some countries, software patents.

How C++ could have disappeared

Of course, it is complete hypothesis that patenting C++ would have caused it not to become as popular as it currently is. However, there is some interesting evidence - due to http://www.unusualresearch.com/ - that this could have happened.

AT&T developed a vast number of systems, many of which were like C++. One such system that they developed was R++. Like C++, R++ was also an extension: but, instead of being an extension to C, it was an extension to C++. Unlike C++, R++ was patented - EU Patent number EP0708401, US Patent 5768480. The abstract beings:

Techniques for integrating rules into imperative object-oriented languages such as C++. C++ is extended to permit definition of rules as members of classes. When a rule is defined as a member of a class, a preprocessor receives the declaration of the rule's class and of any other class involved in the rule and generates additional data members and member functions for the classes. The additional members of the classes permit a complete implementation of the rule.

So far, so much like C++. R++ extends the language into a new domain, by use of a pre-processor translating the new language back into the old. So, why was R++ different, and why haven't we heard about it?

The AT&T divestiture

So far, so good. We have two languages - C++ and R++ - who, by accident of time come from the same place, are similar in terms of what they are (but not what they do), and while one is not patented, the other is. Where is the problem?

Well, the problem is that no-one can really figure out who owns R++. AT&T was split up years ago, and the split has ended up with Lucent being owners of the patent covering R++, but the current AT&T Research Labs being the ones owning the implementation of R++. And, presumably wanting to follow the wisdom of Solomon, the baby was cut in half and hence made unusable to both parties.

So, although R++ might have had the potential to become as popular as C++, it will never be, because legal wrangling over the patent issues has prevented it. Nor can someone else implement it, because it is patented.

It is possible to argue that this split in ownership isn't a fault of software patenting, and in a sense that is true - it isn't the law itself that has caused this problem. But, it does give a glimpse of the quagmire that patent law can become, shows the potential difficulties and complexities, and gives us a good idea of the calibre of tool that we might lose, were we to implement patents.