These days, web frameworks are everything. Whether you’re building a startup, a data-driven app, or even a static HTML website, they’re a requirement for just about every project.
And not to mention, they’re a requirement for a great many jobs. Aside from the junior-est of junior positions, developers are expected to know at least one and in some cases multiple web frameworks to be considered as a potential hire.
Having worked with web development for quite some time now (I’m dating myself a little, but screw it), I’ve witnessed the rise and fall of programming languages and frameworks. I remember how big Prototype and MooTools were until jQuery came and dominated them all. Perl and CGI were pretty big until PHP came along. Drupal and Joomla still have communities, but are nowhere near as popular as Wordpress.
Your Favorite Framework Has An Expiration Date
It’s important to realize that no matter how awesome a technology is, it’ll be gone someday. And sooner than that, it will fall out of vogue. When that happens, the community will thin out, a bigger contender will come along and be the new (and possibly better) cool kid on the block.
It’s wise to code like a Buddhist: don’t get too attached.
As such, developers need to keep their knowledge fresh continually. Freelancers especially so, but in-house technical teams as well need to continue to experiment and always be thinking how to better their situation.
But a good framework will have a 10-15 year run. So it’s important to try and place your money on the safer bets.
Invest in Longevity
It’s important to try to separate the one-hit wonders from those that will live up to the hype for a while. Technology evolves fast, and it’s hard to keep up. As smart as you are, you can’t learn everything (and you sure as hell can’t be good at everything). So when picking new technologies for you or your team to absorb, it makes sense to pick and choose carefully.
Longevity is one of the criteria you should consider when picking which technologies to invest developer time into, and it’s not an easy one to judge. Especially when a framework is new, trying to predict how big it will be in 5-10 years may be akin to fortune telling. But you can make educated guesses by looking at things like:
- What’s it’s track record? How long has it been around?
- How big is the community, and how active?
- How much bigger than its competitors is it? One order of magnitude, or several?
- Does it solve a specific problem really well, or is it very, very broad? What weaknesses does it have?
- Who’s behind it, and how are they nurturing it? (For example: The popularity of AngularJS is probably in no small part due to being created and pushed by a tech behemoth like Google. And they’re continuing to make big moves at evolving it, so it’s unlikely that Angular will be going anywhere for a while.)
Compare and Contrast
Do your comparative research. Every framework, no matter how new has alternatives. The best way to see which one is the most appropriate to learn is to look at them side by side.
You’ll want to rate each according to a variety of criteria that are important to you. From the technical (speed rankings, file size overhead) to the practical (overall learning curve, how well your team knows related technologies), you’ll want to make a very calculated decision on what to invest your time in.
The Bottom Line
I tend to think of learning new frameworks like eating habits: I don’t eat fast food, because it’s bad for my health and is going to make me feel like crap. When picking up new technologies, it’s the same deal – learning more is always a good thing, but it pays to consciously invest the most time and energy learning things that’ll be sticking around and evolving with time.
Your brain and your skillset are investments; give them the high quality stuff and they’ll thank you in the long run.