It is a known fact that nowadays there is a lot of information that can be acquired/learned by developers - new technologies, frameworks, languages and so on.
For those who want to get into development (or maybe are in their first years as developers) this amount of possible knowledge can be overwhelming; they usually seek guidance about what to learn.
The same overwhelming feeling can also be valid in the case of those more experienced in the field, yet in time they find ways of dealing with the idea of learning, with some of them for example having and constantly checking a technology radar.
I suggest a simple way of dealing with it - calling it “framework” would probably be pretentious, yet I’ve been working this way for some time. In fact - the structure of this “framework” can be found sketched in my 2013 Moleskin notebook.
It is about three layers of knowledge - most of the topics you can learn can be categorized in one of these layers. You will be able to learn and tackle topics from a layer once you know something from a lower layer.
1. The fundamentals layer (or the foundation or basics)
This is the kind of information whose relevance hardly changes. It will help you throughout most of your dev career.
As a starting developer you should invest most of your learning effort in this area.
Some topic examples:
- a programming language
- OOP
- design patterns
- http protocol
- databases - types and queries
- algorithms
- tests writing
2. The tools layer (or technologies or frameworks)
They usually come and go, some of them stay relevant for shorter periods of time and others for longer..
The nice thing about this kind of information is that once you are accustomed with one technology or framework it will be easier to switch to another one.
The concepts from this layer are built on top of the previous layer; a developer might have a harder time delving directly into this layer without have a good grasp of previous layer (fundamentals).
Some topics:
- .net framework (including all their apis, e.g. entity framework)
- web servers
- javascript frameworks
- DI containers
- tools (IDEs)
3. The integrations layer (or enhancements)
With knowledge from previous layers - the tools - you are capable to design and have an end product: an application for example.
However, the knowledge from this layer will help in having your application running within expected optimal parameters.
My examples are topics related to:
- architecture
- performance, scalability
- troubleshooting
- more patterns: integration enterprise patterns, cloud patterns
- more advanced tools / frameworks (e.g. WCF)
How to proceed
Having defined the three layers, we can now enumerate some rules on what and when we can learn:
- If you are in your first years as developer, you need to focus on topics from "Fundamentals" and "Tools" layers
- You should know that the topics from "Tools" layer are better tackled if you master topics from the "Fundamentals" layer
- Throughout your career you will keep tackling the "Tools" layer, because it is pretty volatile - they keep changing over the years; but it will get easier to learn the new ones.
- Once you have some experience, expect to tackle topics from the "Integrations" layer more and more
Continuous Updating
Expect over the years new topics to appear, actually expect entire new paradigms which introduce topics on all layers.
One example would be the containerization paradigm which came up within the last years: in this case, containers would be a topic in the "Fundamentals" layer, Docker in the "Tools" layer, and orchestration / Kubernetes in the "Integrations" layer.
Conclusion
Developers need to keep learning throughout their career, and most of them consider this a blessing since the job assumes continuous novelty; however, the continuous stream of new topics should be tackled judiciously. There is a need of a structured and deliberate learning plan - or of a framework; I encourage you to use one, be it the one from this article or your own personalized framework.