Constantly changing framework / API - how will we support the work?

Question

This question is not for any specific technologies, but a more general developer question.

We all know from experience that everything changes. Frames evolve, new features are added, and material is removed.

For example, how does a product using version 1.0 in the "ABC" environment adapt to version 2.0 (can ABC be .NET, Java, Cocoa, or whatever)?

One solution might be backward compatibility frameworks; so the code written for 1.0 will still work in version 2.0 of the framework.

The other may only selectively target version 1.0 of the framework, but this may leave many new features unused (many .NET 2.0 applications seem to do this)

Any thoughts on what we, as developers, should do as best practices to keep our technology up to date without breaking our applications?

Answer 1

Anticipate and invest in change.

Many companies seem to think change is bad. This complicates the other workflow. But as developers, we tend to see things differently.

Changes, in particular new versions, can bring many good things, such as security updates, performance improvements, and features. And most often, change is inevitable. So why not look at it as a reality of a situation, and not a surprise?

You can do things like saving data backups in a format different from the supplier, in case some new technology doesn’t work with inconvenience, and you need to jump from the ship.

In addition, if you have the resources, you can keep old and new versions of something at the same time. Ideally, you would not want your production systems to use the latest and greatest software until someone has rated and signed it. Things like unit tests and beta versions of production system clones can help in this process.

Changes should be accepted, not fearful. Developers, stakeholders, and business people need to keep abreast of new technologies and frameworks. Always be ready for change. In Soviet Russia, the API is not far behind you!

Answer 2

Oh possible answers ....

My thoughts, although not unique (true), are very similar to this.

• Paste your code into your control source - you are using a control source, right?
• In the branch, update the framework (or whatever you have)
• Fix problems in unit tests. Take advantage of the new Framework APIs, remove overvalued links, etc.
• Check carefully.
• [optional] push back into the trunk (maybe it's 4)
• Release to production - congratulations, you are now in a new structure.

This is actually not so simple, but I believe that the simplest answer is the best answer. You should just move forward ...

Answer 3

The only two “solutions” that I see are what you propose: save or switch to a new structure. I think that in general, when your API receives a significant upgrade and your software is important, it is best to evaluate the benefits of the upgrade, and if these benefits outweigh the time it takes to upgrade, the best option would be to upgrade.

Answer 4

Choose a conservative, risky, or interim approach appropriate for your business and follow it up.

For example, if your company is innovating, you will need to use the latest frameworks — or at least freely investigate them. You need to hire people who are interested and comfortable in such an environment - some developers are really enthusiastic about this, others - not so much. Put some structure to make updates safe (branches and static architecture). Customers need to understand the benefits they receive through such an advanced company - if you do not communicate this with them, it may not be what they value, and they will (rightfully) be upset when the situation is violated because of system updates.

Or choose a conservative approach. Choose solid, worn technology and do not plan to update it, except for small releases. According to your words, indicate a specific version. Hire people who value this type of environment.

Or choose something else in the middle of the road.

Each of these approaches is suitable at different times - I was in both extremes in different projects.