Coding Career Advice: Searching and Evaluating Online Information Efficiently
Tags: career
Published: 2021-02-02 02:23:12

---
title: Coding Career Advice: Searching and Evaluating Online Information Efficiently
published: true
date: 2020-11-24 03:00:00 UTC
tags: career
canonical_url: https://blog.isquaredsoftware.com/2020/11/coding-career-searching-information/
series: Coding Career Advice
---

## Introduction

A while back I saw [this excellent quote on Twitter](https://twitter.com/bodil/status/1308783627908583430):

> When I learn something today, I usually do it by piecing together clues gleaned from out of date tutorials and random forum posts until a coherent picture forms, and that is a skill you should practice relentlessly because it's the most valuable skill you will ever acquire.

I attribute much of my success as a developer to my ability to search for information online quickly and efficiently, absorb key pieces of info from the relevant search results, and then synthesize that information into a potential solution.

To be honest, this is a really hard topic for me to write about, because it's something I've been doing my whole online life. It's kind of like trying to describe "How to learn and speak English" as a native speaker. It's not something I can exactly describe based on learning it, because it's a skill I naturally developed back during the dawn of the Web. It's also not something I think about, because by now it's entirely instinctive. Similarly, I can't go tell anyone "start using the internet back in 1995", or "spend most of your childhood learning to speed-read" - clearly that doesn't scale or actually help anyone else :)

That said, I firmly believe that developing a strong ability to search for and evaluate information online is a key skill that every developer should aim for. I actually already described a form of this in my earlier post on [evaluating software libraries and tools](https://dev.to/markerikson/coding-career-advice-evaluating-software-libraries-and-tools-15bi-temp-slug-1312953).

Here's my suggestions for a general set of steps to follow.

## Suggested Search and Evaluation Process

Know _what_ it is you're trying to find. Obviously you don't know the exact details yet, otherwise you wouldn't be looking :) But, think of it as drawing an outline, and then trying to find a picture that matches that outline. The better idea you have up front of what you're looking for, the easier it is to look at a result and say "this does or does not match what I'm looking for"

Know _where_ to look for relevant information. Google is the typical starting point, but I'll use the search feature on other sites for specific things: NPM for JS libraries, Twitter for tweets, Github for code repos or usage snippets, and so on.

Use specific phrases and keywords as part of your search. You might not even know what the relevant keywords are to begin with, but after opening up a few initial results, you might find some info that's in the same general category as what you're looking for. Start up a new search using specific relevant phrases you just found, and keep narrowing the results down based on those. (I'll throw an extra-special shout out to [Shawn Swyx Wang's post on "How to Google Your Error Messages"](https://dev.to/swyx/how-to-google-your-errors-2l6o), which both has some excellent advice for a common problem _and_ tweet-quotes me in the process.)

Learn to skim search results quickly and do an initial filtering pass based on likely relevance. This includes looking at page titles or software library names, "last updated at" dates, URLs, and anything else in the actual search results list that can give you a sense of whether a given result is likely to be relevant and trustworthy. Learn to immediately disqualify search results as "too old", "likely spam or clickbait", or "just not relevant" as you move your eyes down the results list. Pop open potential candidates in a new tab for later review, and keep skimming results.

Once you've got an initial set of potentially useful results opened up, skim the pages and get a sense of what the actual content is and whether it's worth looking at further. Consider the source (blog, docs site, tutorial), date, author, length, apparent level of detail, and overall content. If it doesn't look relevant, close the tab and move on to the next one. The emphasis here is on trying to figure out which of these results should be kept for the the real deeper reading and understanding portion of the process.

Now that you have a good list of likely meaningful results, go back through them in more detail. You might want to take notes on your findings, bookmark some of the results and save them for later, or start up new searches based on some of the keywords you find.

Finally, you should have accumulated a good set of info from across all these results. Maybe none of those pieces of info directly solves your problem by itself, but it's possible to take _some_ of the info as a basis for putting together your own solution. Think of it as lego blocks - maybe you didn't find a complete pre-assembled kit, but you've got enough blocks that you can build something yourself.

Note that these steps aren't limited to Google searches. They apply as you look at just about any other search site or tool, even if you're looking for something like a software library on NPM.

Additionally, one of the main reasons why I still use Firefox as my primary browser is the [Tree Style Tabs addon](https://addons.mozilla.org/en-US/firefox/addon/tree-style-tab/). It lets you switch from a row of tabs on top of the browser, to a sidebar that has a tree of tabs that can be nested and collapsed at any level. This makes it _much_ easier to have a large number of tabs open at once, including grouping results from different searches based on the starting page. (My understanding is that Chrome addons can't do the same kind of UI changes that Firefox addons can, and last I checked there wasn't a good equivalent of Tree Style Tabs for Chrome. Could easily have changed since the last time I looked, though.)

## Examples

I'll briefly describe some specific cases where I went through this process myself.

### Git History Rewriting

In my post [Rewriting Git History and JS Source for Fun and Profit](https://blog.isquaredsoftware.com/2018/11/git-js-history-rewriting/), I described how I completely migrated our team's Git repository history, by stripping out unused files and rewriting the JS source to modernize it at all points in the history of the codebase.

When I started this task, I had some prior experience with rewriting Git history. I frequently used commands like `rebase` in my daily work, and I had used `git filter-branch` a few times. I also generally understood how Git's data structures worked, and that tools like JS codemods existed. So, I understood the general shape of what I wanted to do ("create an alternate Git history but with changed content", "rewrite JS source automatically on a large scale") and key terms that I needed to look for ("`git filter-branch`", "rewrite Git history", "JS codemod"). I also assumed that what I wanted to do _must_ be possible, _somehow_ - I just didn't know the exact technical details of how.

I probably spent at least a week doing initial research on this. I didn't find an exact solution, but I did find several critical resources that gave me much deeper understanding, key terms to look for, and ideas that shaped my potential solution:

- [Understanding Git Filter-branch and the Git Storage Model](https://manishearth.github.io/blog/2017/03/05/understanding-git-filter-branch/): helped clarify my understanding of how `filter-branch` works and how Git stores its data
- [Large scale Git history rewrites](https://www.bitleaks.net/blog/large-scale-git-history-rewrites/): gave me the idea for doing some of this work in Python
- [A tale of three filter-branches](https://wincent.com/blog/filter-branch): described a rewrite process, and linked to a Ruby script that did low-level Git repo manipulation to speed up the rewrite work
- [`sergelevin/pylter-branch`](https://github.com/sergelevin/pylter-branch): a Python lib that builds on `pygit2` to provide an abstraction for iterating over Git history and rewriting it

None of those pieces by itself was the entire solution, but together they gave me enough understanding to figure out how to build the actual solution I needed.

By the time I was done building this, I had learned enough to write [a 6000-word blog post on the topic, off the top of my head, in about 5 hours](https://blog.isquaredsoftware.com/2018/11/git-js-history-rewriting/) :)

### Searching for Info on How to Search

I started this evening by searching online and evaluating info on how to search online and evaluate info efficiently. (How meta!)

My first search was for [`how to search for information on the internet`](https://www.google.com/search?q=how+to+search+for+information+on+the+internet). In a sense I didn't follow my own advice here, because that's more of a question or a phrase than specific keywords, but I didn't quite know where to start looking for details on this topic. Most of these results were either blogspam about search engine optimization, or too narrowly focused on how to actually type things into a search engine rather than how to look at the results. I also avoided any results with dates older than the last couple years, on the grounds that they probably weren't as relevant.

That initial search turned into [`effectively evaluating search results`](https://www.google.com/search?q=effectively+evaluating+search+results), which produced some better hits. I also saw the phrase "digital literacy", realized that was a relevant aspect of this topic, and searched for [`digital literacy searching for information`](https://www.google.com/search?q=digital+literacy+searching+for+information). These queries gave me some better results, including a number of academic-related pages like university libraries.

Ultimately, I didn't end up using those resources to write this post, but I have linked the best results in the "Further Information" section below.

### React-Redux, React Native, and Jest

Last year I fixed [a bug in React-Redux where it broke under React Native](https://github.com/reduxjs/react-redux/releases/tag/v7.1.2). As part of that, I needed to update our test suite to make it correctly test behavior with React Native, vs just ReactDOM.

I remember having seen a tweet that day about "all the stuff I googled in a week as a software developer", so for fun I wrote down [every Google search I did while trying to solve this particular React Native test setup problem](https://gist.github.com/markerikson/5a7ea2d1053c2714d6d709294c970536). This included searches like `react uselayouteffect ssr` to find a particular issue thread I knew existed in the React repo, `jest mockComponent.js Support for the experimental syntax 'classProperties' isn't currently enabled` to find a solution to a particular error message I was seeing, and `microsoft ipod naming` as a sidebar based on a discussion with a friend, to find the classic Microsoft self-parody video on how they're so bad at naming things.

## Further Information

- [Seven Ways to Find What You Want On the Internet](https://www.mindtools.com/pages/article/internet-searching.htm)
- [Curtin University Library - Effective Internet Searching](https://libguides.library.curtin.edu.au/c.php?g=909870&p=6553346)
- [Girton College - Planning a search strategy and picking a search engine](https://www.girton.cam.ac.uk/e-guides/effective-internet-searching)
- [University of Exeter - Effective Search Techniques](https://libguides.exeter.ac.uk/searchtechniques/planning)
- [How to Evaluate Websites: A Guide for Teachers and Students](http://www.kathleenamorris.com/2018/11/20/evaluate-websites/)
- [Stark State Library - How to Evaluate Websites](https://libguides.starkstate.edu/websites)
- [BYU Library - Step by Step Research Strategy Guide](https://guides.lib.byu.edu/c.php?g=216340&p=1428395)
- [Webwise - Digital Literacy: Ten Steps to Better Web Research](https://www.webwise.ie/teachers/advice-teachers/digital-literacy-skills-finding-information/)
- [Media Literacy Starts with SEARCHing the Internet](https://www.iste.org/explore/Digital-and-media-literacy/Media-literacy-starts-with-SEARCHing-the-internet)
- [How to Google Your Error Messages](https://dev.to/swyx/how-to-google-your-errors-2l6o)
- [How do you learn programming topics?](https://swizec.com/blog/reader-question:-how-do-you-learn-programming-topics)