Backward compatibility and programming languages

An issue I see with the development of programming languages over the years is the problem with a lack of backward compatibility.  New programming languages continue to drop older code syntaxes and features while continuing to to add new features. Nothing scares a long time programmer more than to hear that his favorite programming language or maybe just features of it have become obsolete.

Some may say that this is the price of progress, but I don’t think so. Why ?

Programming is a complex trade to learn and it takes time for programmers to hone their skills. Better programmers have developed a style of coding which works for them and they build quality libraries and tools to support that. The old saying “there is no need to reinvent the wheel” is true and programmers should be able to write reusable code once and be able to come and use it when needed. The problem is though that if the programming languages keep changing without reasonable backward compatibility, then what happens is that even experienced long time programmers find themselves constantly having to “reinvent the wheel” over and over again. This causes a significant loss for businesses because they have to spend money just to keep current, while not actually getting any more real value from it.

I have a few past customers who I wrote custom software which is critical to their businesses who are still using old DOS or Windows 3.1 software today after about 15 years. As long as the software still works and does the job and they can find a way to keep using it (ie. not use the latest version of Windows) they see no reason to change and I don’t blame them. Now I never imagined my software woul last this long, but it has and those using it have definitely gotten their moneys worth from it.

There is nothing wrong with improving software and improving programming languages, but if done at the expense of backward compatibility something is definitely wrong. To appreciate this, consider accounting software. I have watched customers over the years use different accounting or payroll sofware and I find it interesting how much effort the developers of such software went to make sure that a new version of their software definitely could either read the old databases or could convert the old databases to a new more current format. People who used such software would be very, very upset if they were forced to reenter all the data into the new version of the software simply because it refused to read or convert the old database. Yet that is exactly what companies who make programming languages often do to programmers. The programmer buys the latest programming tool and then they find out that they have to literally throw away a lot of their old code and “reinvent the wheel” all over again using some new syntax or something else.

This is not right and not fair to all the hard work that goes into developing the skill of programming.

This is one reason I have stuck with the BASIC programming language and also why I use PowerBasic. I have been able to use code which is 10 or 15 years old and port it into PowerBasic with few problems. True some things have changed out of absolute necessity, but PowerBasic has maintained a proper connection with the past (BASIC) while adding many new features for the future. I just can’t understand when I see programmers today say things like “Basic must get rid of obsolete syntaxes like GOTO or GOSUB” for the sake of being modern. Getting rid of GOTO or GOSUB doesn’t make a programming language better! Who are they kidding. If they ever took the time to learn machine language they would appreciate that without GOTO and GOSUB (and their machine language equivilents) modern computers would not work. I guess particularly the OOP community have done a great disservice to programming languages by labeling many older long time code syntaxes as old fashioned, obsolete or even down right dangerous. That is absolutely not true. Now when you look at PowerBasic they did the right thing. They added OOP (classes) for those who prefer (or only know) it, while still maintaining the code original BASIC syntax such as GOTO, GOSUB, ON GOSUB, etc. It should not be a matter of “either or”, but of backward compatibility so we don’t have to throw away code, but adding new features along with it.

Many software companies could take a lesson from PowerBasic in this. They also could save a lot of money by reusing code which has proven itself over time.

I certainly have learned this lesson, not only because I use Powerbasic, but with my own software tools that I develop which other programmers use I consider backward compatibility critical. My own EZGUI is not in its fifth generation and I have worked hard to not break old code my customers may have worked hard on and if a change had to be made try to make it as painless as possible.

This is a valuable lesson that all software developers (and those who make our tools) should learn.