Software is vast and growing. It seems like every week a new editor, library, framework, or language is released. I've written before about the value of learning things that are unnecessary, but with so much material, how do we find the unnecessary amidst the unrelated and unhelpful. How can we separate the signals from the noise?
Here are some patterns i've noticed over the years. Today, these are the mertics i use to priotize which tools to learn, integrate or let pass by.
Watch the bubbles
Most new technologies make a splash. After that splash come the mentions of that technology from the engineers who have adopted it. I call these mentions bubbles.
In my experience, the size of the splash does not represent the quality of a new tool. What matters are the bubbles. How often is it mentioned? Are the mentions positive? Are people extending the new technology or working around it?
Generally, if people are looking for new ways to integrate a technology, it bodes well for its value. Also, if mentions of a new tool continue long after its release, it is also a good sign. Which brings us to the next litmus test.
Take a breath
In recent years, some libraries have caused such a splash they seem to define a new ecosystem entirely of their own. These situations both command attention, as well as measured patience. The reason for this patience is that new ecosystems often lead to competing technologies. When this happens, seeing which way the community leans is important.
Now, this isn't always the case. When NodeJs was released, an ecosystem was born, but a competing technology never really appeared. Instead, Node has thrived from packages looking to extend its capabilities, instead of tools that are similar but different.
Old is not irrelevant
Some tools remain relevant decades after their release. You can usually identify the important ones by how consistently you hear about them. Things like, vim, awk and regular expressions come to mind. They are not glamorous, but their value is unquestionable. Learn them, for your sake and the sake of your teams.
Many of us have a list of tools we picked up as soon as they entered our radar. In retrospect, was the technology choice the right one? In my experience, rarely has including the newest tech been the right move. There is almost always value in learning it, but maintained codebases need to move slower in their adoptions.
Just keep in mind that while learning is never a bad idea, learning relevant techs is always a good idea.