Many software developers are uncomfortable with trying out new technologies. They believe that they need to learn something new all over again. They start to think back to when they started learning the technologies they use presently and think “I don’t want to go through that again”. The knowledge that they worked so hard to acquire would have gone to a waste.
The scenario I described above is a barrier for many developers (myself included) that blocks their way to grow. Realizing I need to get out of my comfort zone as a developer, I made the decision to learn other technologies. What I realized is that it isn’t so bad because I didn’t have to start from scratch. A lot of the knowledge I have will still be useful to the new technologies I was learning. So, for this post, I will be talking about six core transferable knowledge that remains valuable regardless of what technologies you decide to try out.
Software Design Patterns
There are multiple software design patterns out there. You probably have heard of some of them: MVC (model-view-controller), MVP (model-view-presenter), and MVVM (model-view-viewmodel). Although the implementation details will vary depending on the programming language, the high-level idea of each design pattern remains the same. So, if you have experience working with a certain design pattern that knowledge will immediately benefit you when you start using new technologies.
Object-Oriented Programming
The concepts of object-oriented programming (OOP) is completely transferable to other technologies you decide to use. The only exception is if you are using procedural programming languages such as C, Fortran, COBOL, and BASICS to name a few.
At the high level, inheritance, polymorphism, encapsulation, and abstraction works the same between different programming languages. Where things differ is in the syntax and other finer details like the access specifiers. For the most part, if you have a solid understanding about OOP then you can easily bring that knowledge over to a new project.
Thinking for Multiple Platforms
Software nowadays runs on a variety of platforms such as mobile, web, and desktop. There is no one size fit all for all platforms so it is important to have different implementation for each platform. When you have experience developing for a diverse set of platforms you build a mindset that looks at developing software where it will satisfy each platform. Regardless of the technologies, having a mindset that thinks about developing software for a diverse set of platforms is applicable to any software project.
Version Control
The knowledge of working with any version control system is transferable. The specifics might be different between version control systems, but the use case for them is similar. For example, if you know git then switching over to another version control system such as Mercurial or TFS (team foundation server) will not be very difficult. You already have a solid foundation for how version control works and the general flow of using it in development.
Multithreading Fundamentals
Implementing multithreading is going to be different for each programming languages. However, the fundamental concepts associated with multithreading is transferable. In any scenarios where it involves multithreading, the fundamentals will be involved.
Consider these two scenarios. In one, you make use of multithreading with some really high-level APIs that takes care of everything for you. In another, you make use of multithreading by using low-level APIs where you need to do a fair portion of managing. In both cases, you end up with the same outcome (using multithreading) but in the low-level API case, you learn about the fundamentals such as race conditions, deadlocks, atomicity, semaphores, etc.
If you have done multithreading with only high-level APIs then you’ll have a hard time transitioning to using multithreading at a low level. Conversely, if you go from low-level API multithreading to a high level there is no problem. So, what this demonstrates is that by having a good understanding of the fundamentals to multithreading you can easily transition to other languages.
Data Structure Fundamentals
Why are you mentioning only data structure? What about algorithms? Well, there is a reason for that. In real-world software development, you’ll be dealing with data structures much more than algorithms. You will rarely be writing your own algorithm. Instead, you’ll be using libraries that have the algorithm implemented, tested, and optimized.
You can argue the same case goes for data structure too. How often do you write your own List, Array, Stack, Queue, and etcetera? Probably almost never because they are almost always part of the programming language you are using. What is transferable and important is knowing the difference between each data structure.
It is important for you to understand how each of the data structure differs. What is the difference between a Stack and a Queue or List and Array? How do they store elements differently from one another? How do you find an element in each one of them? These are fundamental concepts that don’t change between programming languages.
I hope this post was helpful to you. If you found this post helpful, share it with others so they can benefit too.
To get in touch, you can follow me on Twitter, leave a comment, or send me an email at steven@brightdevelopers.com.