« Home | Microsoft JET Engine » | LINQ » | New Methodolgy for Explaining Software Engineering... » | PInvoke and IJW » | DBMS Blogs Moved » 

Wednesday, September 06, 2006 

Should we always stick to backward compatibility?

Backward compatibility is always a major concern when writing a new application or adding a new feature to a technology standard.
The problem is that standards are in many cases wrong or at least not complete. Many cases can easily be found, such as C++, the web standards (HTML for instance) and SQL.
One of the things that prevent us from destroying those wrong standards and replacing them with totally new standards is backward compatibility. But does it really worth it?

I think backward compatibility is important when building a new application. You want your users to be able to open their old files although you have made a new file format. This is something that worth working for, but for a technology or a standard? I think here we should stop to thing about some time.

Take the web as an example. How many problems do web developers face and have to hack because of the different ways browsers deal with html and asynchronous java script calls? One of the main causes for this is that the possible ways you can deal with web standards are endless. Why don't we ignore all the backward compatibility completely in such a situation?
Lets say we are about to put new web standards, browsers, and protocols. Those who are satisfied with the old standards or their application contain old code can continue to use old standards and web development tools; those who are creating new applications from scratch can use the new standards. Developers of totally new applications don't have to face all those problems because "we cannot change the standards completely for backward compatibility reasons".

Take a look at C++ and the amount of problems and difficulties and pitfalls that are found in some parts of the language and known to every C++ developer, say for example templates.
When putting new C++ standards, why don't we ignore the past completely? There is a good number of compilers for the old C++ that can be used for editing old code and be used with old libraries. We can start a new C++ era with a new language that totally ignores the old problems and make new compilers for it. Of course the industry will not move in a second from old language to the new one, at least because of the big amount of C++ libraries, but those libraries will be replaced sooner or later by big and small companies. See for example the .NET base class library and how it was developed from scratch.

The end result that we would get in a few years if we ignore backward compatibility when putting new technology standards is a new software development era with less development cost, time and bugs, happier developers and users.

Isn't it a lovely idea?

So, you put out your C++ ++ (aka C#), or newCSS and people find problems with it, which you patch in version 1.1.

Now you're exactly back where you started, aren't you?

I don't mean small changes, I mean big major changes to things that every body knows they are wrong or missing something, such as changing C++ templates to something like C# generics, etc.

Post a Comment

Links to this post

Create a Link