Technical considerations when dropping support for older versions of the compiler?
I am working on a project that is free in both source and binary form, as many of our users have to compile it specifically for their system. This requires some degree of backward compatibility with older host systems and, most notably, their compilers.
Some of the most brutal ones like GCC 3.2 (2003!), ICC 9, MSVC (almost forgotten, not C ++!) And Sun compiler (in some old version that we still care about) do not have language support that would greatly simplify development. There are definitely also cases where users who might stick with these compilers are wasting more performance on them, which is contrary to the goals of what we provide.
So at what point do we say enough, enough? I can see several arguments in favor of dropping support for a particular compiler:
- Poor performance of the generated code (relative to newer versions given here )
- Lack of support for language functions
- Poor accessibility on development systems (more for proprietary than GCC, but there are sysadmin issues also having old GCC).
- Possibility of uncommitted errors (we have highlighted ICE in ICC and xlC, what else could be hidden?)
I'm sure I've missed some of the others and I'm not sure how to weigh them. So what arguments am I missing? What other technical considerations come into play?
Note. This question was previously worded more broadly, prompting many respondents to point out that decision making is primarily a business process, not an engineering process. I know "business" considerations, but that's not what I'm looking for here. I want to hear experiences from people who have had to support older compilers or have made the choice to ditch them and how this affected their development.
source to share
Your question is conceptually the same as for web developers who want to know when they should end support for Internet Explorer 6. The answer is that you need to do research.
- How many people use older compilers?
- How many of them use the newer ones?
- How many will be ready to upgrade?
- How many users will you lose? (This can be calculated from the answers to 1, 2, and 3).
- How much time and work will it save you to drop support for older compilers?
Basically your solution comes down to comparing answers from 4 and 5. It looks like it is an open source project from your description, but if it is a business, you can compare it numerically (if the money lost is less than the money saved, drop support) ... If it's not a business it is a little more difficult as you have to guess the human costs, which can be a little tricky.
source to share
Well, the usual way to start is to ask first. I am assuming you have a web page mailing list or something. So ask who will be affected and how difficult it will be to update if we drop support for any of these compilers. You will then get an idea of whether these compilers are worth supporting.
It can also be helpful to mark the latest working version for each compiler version you decide to drop support for, so that anyone who really cares can continue to use that old version.
source to share
I don't think this is particularly important for the efficiency of old compiler technology. This is a business decision and it really comes down to whether you want to keep your customers or lose them. Clients don't deal with technology; they make business and business decisions.
Ideally, you want to define some kind of metric based on how many clients you have, versus the different versions of the compiler they use, versus the cost of supporting specific versions of each compiler type.
Basically, you really need to be careful when and how you are going to tell your customer based on the fact that you are going to take away some of your product suite. As you tell them. Just drop it on your knees. Plan it.
You need an internally approved supervised policy and start deploying it, perhaps to user group meetings, and then make sure you have a decent lead time (2 years ok, let the client finish current implementations (1 year) plus some weak ones before proceeding with implementation and have a support system to help the client migrate on time.
How you plan for this will determine how your customers react. A few years later, I worked for which I sold a really sophisticated high-performance power grid management product. The product sells £ 2 million for the entire package, and each customer has signed a 25-year support contract. For some reason we decided to rationalize the equipment. We've been offering it on AIX, Solaris, Tru64 and HPUX. But for this reason, we decided to rationalize this on AIX, and I think we had a deal. Anyway, one of the customers who was a Solaris store got very upset about it, and then for the next 4 years we never heard a word from them. No phone calls, fixes, audits on the site. Nothing.
The reason we decided to change it is because we did a 6 Sigma project and it indicated that we would save about £ 19 million a year by buying infrastructure rationalizations for AIX and NT. But in the end we ended up working with one of our main clients, effectively wiping out the user community.
The decision was taken in haste and received feedback. So I think your best idea is to plan it out.
source to share