As I said about F# in this post, I used a sort of "maturity model" to learn new languages/platforms. That's at least my way of learning based on some experiences, I don't know if it would be applicable to anyone. So I would like to expose facts that lead me to this "model".
Note I use quotes for "good" and "best" qualifiers for practices, because I don't really like these words, as they are judging practices without really having real and tangible proofs of what is good or best (context dependent probably?). It could be another subject to write on...so let's continue.
A bit of history (about my experiences on .NET and Java)
During first years of working (2004~2008), I focused on .NET platform (cause I was paid for...), but in my free time, I always kept a eye on Java ecosystem because it was my initial education. From the beginning (of my "career"), I was interested in improving my skills. Around 2004, there was a lot more new things in the Java ecosystem than in the .NET one (or it was more confidential). In my opinion, the key was the community, lots of things emerged from the community in the Java ecosystem. .NET ecosystem was more focused on improving language, open source community was emerging slowly, and Microsoft was still more focused on Visual Studio wizards than trying to really improve development practices...
During the first year, I was mostly trying to deliver "value" on (ugly) legacy system, learning and using .NET language and tools, since I knew only Java when I started. I had a look at NUnit, I tried it, but I was not aware of TDD, neither of SOLID principles...it was too much things to master at this time.
Then, during the three following years, I started "from scratch" projects, trying to deliver value the "good way", based on knowledge I acquired previously...but I felt some "things" were still missing...obviously, I learned lots of new things also, following evolution and emergence of .NET community.
In 2008, I started to go to meetups (Alt.Net in Paris) and discovered that my feeling I was missing "things" was not an illusion :). Meetups helped me a lot to discover quickly (lots of) things I did not know. I was more confortable with language, frameworks and libs, and I started to focus more on practices and concepts (patterns, architecture styles...).
From this first 4 years experience, I feel I had to go through learning basic stuff about .NET platform, before I could try to dig practices and concepts. That is the base of "a sort of maturity model" I would like to talk about here.
A sort of "maturity model" for learning a new language/platform?
Today, I feel like I could work with any language/platform tomorrow, but would I be efficient/productive? I think that when you learned a language and you try hard to always search alternatives, you are able to start with a new language/platform.
But the question is how to become more efficient with it. From my experience, I would give the following guidance, that I call a "maturity model":
- Know the language
- Know associated tools, frameworks & libs
- Use practices
- Make contextual/deliberate choices: tools/frameworks/libs/practices you need
Note that I put practices usage (like TDD, clean code...) quite late in the model, because I think at start it could be a distraction more than a real help at first. Also, I do not consider this model as a silver bullet, for sure I adapt it to context. For example, I can start learning some tools without knowing everything about the language, or I will start using some practices as of I know some tools helping to use them, I don't need to know many tools to start.
I also make a parallel with Maslow's hierarchy of needs. We could see the language as the physiological, tools as safety, frameworks and libs as love/belonging, practices as esteem and contextual/deliberate choices as the self-actualization/transcendence :).
Let's dig my experiences after 2008 to exercise this model. Note that following experiences occured after having started to practice TDD and other practices.
My (small) experience with JS & Node.js
I used JS from the begining, but the hard way without any lib (I was targeting IE6!). Then I switched to jQuery. My JS development was like the poor man of my stack, I knew I was not doing "well" (or least "as good as" in .NET), I can't exactly explain why I did not try to improve in fact...a bad excuse: missing time? ;)
Lately, I started using dependency management lib like Require.js, even more lately, I used a bit some build tools like Gulp, Node.js with browserify, I started practicing TDD (with Jasmine and Mocha)...
Retrospectively (biased?!), I think I did not consider JS as a core knowledge (as lot of developers I think), so I did not spend enough time to improve my skills. In fact, I was missing some basic ones to be able to use practices like TDD. And I did not even tried before I acquired better basic skills in JS. I suppose I would have struggled if I tried.
My (small) experience with PHP
My PHP skills were very basic (back in high school, for an association website ;)). I was "sold" on a project as an architect who knew web development, e-commerce, MVC and "software good practices". I was requested to help rebuild a (ugly-old-style) PHP website...
I also faced a team with low development skills, I mean even in basic OOP. In this context, when we discussed about "how to start?", we reviewed two main options: use Symfony framework as a base VS everything-from-scratch...I did not want to go the "everything by the framework" way, but in the other hand I did not think we would manage to start from scratch given team skills. Note I include myself, since I was absolutely not proficient in PHP, even if I know "more" about architecture and practices...
This experience tend to verify my model, we missed skills to make a deliberate choice, the team knew the language, but not enough about tools, frameworks, libs, practices and architecture, on the other hand I did not know enough about the language and tools...so we were not able to make a deliberate choice and made choices that we do not completely master.
My (small) experience with Android
I started Android development with lot of confidence, because I thought I knew enough about Java and I could accomodate with the framework given my "higher level of abstraction" skills acquired in other languages...and it was a hard experience.
I tried hard to do TDD, with the terrifying discovery it was quite difficult to find TDD resources based on Android platform. I discovered things I did not know about Java (with a bit of desillusion sometimes...like the generic types implementation). I struggled with the Android framework and its high-coupling aspects...
In fact, with the proposed model light, I would say I tried to use practices and concepts, without knowing anough about lower level of abstraction like the Java language itself and the Android framework. In the end, I am not sure I chose the best approach to develop an Android application. That was the first time I thought about this sort of "maturity model".
My (ongoing) experience with F#
Given my previous experience, for my last learning experience (F#), I tried to apply my model. First, I thought I should focus on the language first. Note that sometimes at the beginning of this learning process, with @florentpellet, we tried to do TDD in some coding dojos, and in fact, we often just managed to make one or two tests, struggling with unit tests tools more than learning the language...
After practicing the language, now I focused on tools and libs (this blog "engine" was an occasion to use some). Now I start to practice TDD, and I feel more confortable because I better know the language and some tools (I am still learning language, other tools and libs...).
I would be pleased to have your feedbacks on your experiences and your thoughts on this sort of maturity model.