Perspective-Driven (Self) Development
🎓 Introduction
Perspective-Driven Self Development is the learning idea that can potentially enhance the way you acquire knowledge with increasing your confidence and sense of reliability along the way. Warning! Step with caution! The fun coming from it is highly addictive!
Why "potentially", though? Because it is a way that may not be suitable for everyone. And it's fine! This is the way I do things personally and I wanted to share the concept with you. Nevertheless, you may approach things differently. The most important thing is to find a way that suits YOU best.
The principle itself is pretty simple and let me emphasize it:
Try out new things!
That's all, folks. ✋🎤
Well, I didn't discover anything new, did I? We, developers, are constantly attracted to new, shiny ✨ things, which can be both good and bad. But I want to state it boldly here - there's nothing wrong with that! It's fun! It's educating! It's practical!
⚡ Why you (should) use it
Speaking frankly, I'm fairly certain that you are already using this idea in your career as a tech person. You being here is enough proof! Reading articles like this, means that you saw it on Twitter or you follow my articles for some time (which would be pretty weird, because I don't think I'm that popular). That, in turn, means you strive to broaden your perspective by engaging someone else's articles, tutorials, researches, etc. You obviously want to improve and that's wonderful!
Perspective-Driven Self Development is beneficial because with a wider perspective you start to see patterns. You've probably noticed by now, that practicing one OO language makes you understand another one waaay faster. The same is with libraries or frameworks that serve similar purposes. The same might be with cloud providers, databases, architectures, paradigms, languages, etc. Let's call those "learning domains" from now on.
Wider perspective boosts up your confidence - you seem to have more answers on all kinds of different questions because you've tried all kinds of different things! You won't have all the detailed knowledge in the world in your head, that's obvious. Although, there probably was a time when you came across a very difficult problem but managed to solve it by remembering, that someone, somewhere, solved the same problem. The piece of code/article/video you may have seen a couple of weeks ago while rummaging through the internet can change the game.
Another thing is, that if you're just starting your journey in tech, this idea can help you get a sense of yourself. You'll start to get a hang of what are the things that bring you joy and you can just dive deeper into them.
It's worth to mention that Perspective-Driven Development is highly compatible with the Learn in Public concepts by swyx. While trying out new things and broadening your perspective you can use your newly acquired knowledge, e.g. build something fun and share it with others. You can do it via blog posts, talk at the meetup, a tutorial video - the floor is yours.
📜 Examples of learning domains
When you start learning databases, you could start with MySQL. Then learn Oracle or PostgreSQL because... reasons. But wait, there are all sorts of databases! Non-relational, temporal, graph, client-side (those are just random examples). It may be cool to try out something different and check out what are pros and cons, use-cases, what fits you best etc.
When starting with front-end development you have an enormously wide range of things you start from. This page (https://andreasbm.github.io/web-skills/) lets you see just how wide ("overwhelmingly" seems like a polite understatement 😨). The simplest example might just be when it comes to JavaScript frameworks. Once you've squeezed everything you can from framework X, you can try out framework Y - you might just see how much faster it takes to learn it.
My personal favorite is a paradigm-shifting because it's the most challenging of them all. After years of learning one programming paradigm, it's hard to just shift your mind in another direction. The most popular example of that is learning FP after years of writing software in OOP (or another way around). After two years of programming in OOP (mostly Java and somewhat TypeScript) and learning all those principles (classes, inheritance, encapsulation, etc.) I've heard of this mythical Functional Programming and how complex but rewarding it is. I just couldn't help myself. I felt the challenge and couldn't wait to tackle this. After a year of learning FP, I still don't get a lot 😂 But I don't stop and every step forward feels rewarding. Let me tell you, when you feel excited just by a thought of trying out new things - you are a 100% follower of Perspective-Driven Self Development.
⚠️ Mind the downsides
Something can (and probably will) go wrong when practicing this approach. There may be a time when you devote your time to something and fail. An example of that might be discovering that some X bundler isn't as simple or "automagical" as it seemed and cannot be used for your project after two weeks of trying. But don't be discouraged - there's always some knowledge coming from a failure! The next time you test another bundler you might just know what to focus on and try it out in the early stages.
Far more dangerous is taking this idea too far. If you spend too much time trying out different things, you might end up knowing too little of your main field of expertise. E.g. focusing on knowing different frameworks might end up with knowing 20% of each and that's not healthy for your career. Another, much broader, example is differentiating roles at your workplace. Should one person be a business analyst, a developer, and a tester at the same time? It's great to have knowledge of what each role is and what are their responsibilities but you probably should not do their job. That's too wide of a perspective to acquire by one person.
🧘 Conclusion
Considering the last part (the downsides) I'd love to give you some personal, concrete piece of advice - a recipe, a golden ratio, let's say.
Pick up the learning domain you want to improve (e.g. JS framework), define the main branch that you should pursuit (like framework X, because you use it at work) and use 60-70% of your time to focus on that. The rest of the time you want to devote to the learning domain can be distributed among all other possibilities (framework Y, Z, etc.). It's healthier this way. Also mind that - the more you feel confident with your main learning domain, the more this ratio can drop, finding more time to learn new things.
Hell, what else can I say, you should just try it out yourself (if you don't already)! Happy learning!