Manage Change by Managing Unchanged

As a software developer, we have to deal with different changes:
 -  The changing requirements, which means change code, bug fix, revers engineering...
 -  The changing technologies, you have to deal with new buzz, new API, new languages...

How can we deal with these changing? because chasing change is really hard, because:

• New stuff in software industry are too much, they are out of control, every year there are so many buzz, languages and SDKs waiting for you;
• Some new stuffs are quite easy to obsolete, some time even when you try to start learning it, it is just gone.
• Understand too many details in short time is really stressful
• They are quite context specific, they will be useless in different area.

Since human's time and energy is limited, how can we manage these changes properly? Why not focus on unchanged stuff instead of changing stuff? What I mean the unchanged is something behind the detailed technologies. For example, like principles, rules, patterns, philosophy etc. They are more general which means last longer, they are also the high level abstract knowledge which easier to transfer another area, so based on these 2 characteristics, they are manageable.

Another interesting characteristic about unchanged is they are meta level of details. For example, measure an object's change of position, then we use velocity, which is can be thought of meta position: the change of position; if we want to measure the change of velocity, then we use accelerator. This example means the higher meta level, the less likely to change and easier to manage.  Another example is in software developing, in object oriented developing, the object's meta level is class, the class's meta level is meta class, we manage the class to make the code more reusable, we manage the meta class to make the code more dynamic and more adaptable.

So how does the concept of "Manage change by manage unchanged" help in the software development?

•  We should focus more on classics, like algorithm, data structure, fundamental computer theory, OO design patterns, OO SOLID principles, etc. because they are fundamental and general, they are powerful, they are going to still valid for a long time;
• When you learn a new technology, or a new SDK or even a new language, don't try to remember every details, which will overkill you, but you should focus more on the principles, rules or philosophy, since detailed technologies are easy to forget, but when you understand the principles behind the details, it is much easier to memorize, and much easier to transfer to another area;
• It help you to identify which technology is worth learning by analyzing its unchanged properties
• In software design, when we design an adaptive software system, first we need to identify the changed stuff and unchanged, then design the structure based on unchanged, then isolate and encapsulate the changed stuff; make sure the system depends on unchanged, not on changed, this is the famous Dependency Inversion Principle.