Stop Skimming Documentation

Look, whether you’re a Linux user, a hardcore webdev, or even an IT technician, docs are a part of all of tech, but few people actually understand how to read them and more specifically absorb them.

If you prefer to consume this article as a video, check this out!

But Oscar... 😕

Now look, I hear you saying “but Oscar, I just read the whole Rust book” or “I just read what I can’t figure out on my own – people don’t know how to read documentation because these 20 page documents aren't necessary anymore”, and we’ll get to that in a second.

Because yes, you’re right, documentation comes in many forms – READMEs, autodocs, and even videos (yes, Google makes videos sometimes instead of writing documentation).

And as we get better at documenting our stuff, the need to have the patience to read through that 20 page document drastically decreases.

But lemme ask you this (and I want you to actually, truly, think about this): are you reading the docs, or are you absorbing them?

This is what you should be!

Can you recall everything that you just read about Rust or a Linux tool or some other technology that you’re learning? Well, probably not, and that’s normal, it’s not bad.

But you probably can’t recall as much as you should be able to. See, a lot of us get sucked into this notion of reading without comprehending – and this brings me back to what I just said about reading docs instead of absorbing them.

Absorb it! 🌊

Documentation, and really all forms of writing, are meant to be thought about and understood and comprehended, and when you just graze over a bit of writing, you’re not actually doing anything of that nature.

And this makes sense. Your brain isn't like your Linux, unfortunately. You can’t just throw something at it and expect it to perfectly copy everything down – and you probably know this.

Now there are a lot of strategies to mitigate this and we’ll talk about some in just a second. But first let’s talk about why – why should you care about being great at reading docs?

And don’t worry, I’m not gonna try and sell you on this idea like your high school counselor telling you that reading is a skill that employers value.

Let me actually explain to you why you should learn how to actually absorb the information from the documentation that you read.

Why? ❓

Why, oh why, should you actually care about your documentation reading skills?

Because Linux 🐧

Firstly, Linux (and any widely used technology that isn't dead simple).

All of the try hard tech people, myself included, want or need to use Linux, but I don’t think a lot of people are aware of how much time it takes to learn to use Linux. And not just time, but effort. If you’re at all aware of how complicated Linux can get, you’ll know that there’s a lot of documentation reading involved.

And well, if you skim everything that you try and read or watch, you’re gonna be forced to re-read a lot of what you just read. This is an energy drain: it’s demotivating, tiring, and it really kills the fun of Linux, or again, whatever tool you’re trying to use.

I myself can confidently say that I’ve done this plenty of times: I skim over the initial manpage and then spend the next 20 minutes wondering why I don’t understand the CLI or program that I’m trying to use.

Just look at this documentation!

And as I mentioned, the Linux analogy can be applied to everything. Any language, framework, or library worth your time is going to have a considerable amount of documentation behind it, and if you can’t effectively absorb it, you’re kinda cooked.

Tutorial hell 🔥

Secondly, this is the best way to get out of tutorial hell.

If you’re not familiar with tutorial hell, it’s basically this state that every tech person reaches at some point. You’re advanced enough to do your own projects, but you’ve been following YouTube or FreeCodeCamp tutorials for so long that you don’t want to and don’t know how to build a project without a narrator guiding you.

By the way, if you’re in this right now, let me know. I’m curious.

Anyways, being fluent in docs is one of the best ways to help yourself out of this state, and even if you’re not actively in this state, you might find yourself or a friend there at some point, and this can really help.

For you! 🙂‍↕️

Thirdly, this is kinda obvious: this is for your own benefit.

The more efficiently you can absorb information, the more time you have to do the fun stuff, like coding, and getting stuck on really stupid bugs… that’s about it.

Not only does this benefit you, but it benefits everyone around you.

![A group of strongmen(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/o1ik0wat5ecueq3sqzhz.jpg)

Having someone that’s comfortable sitting down and absorbing a bunch of information out of a man page or something similar is extremely useful, and you’ll find that as you become a better information sponge, you also become a fountain of knowledge.

Ok, but how do I do this? 🫤

Ok, finally, let’s talk about the how. This is the fun stuff.

There are a lot of different ways to go about this, and if you wanna learn more about this, just look up “how tf do I learn from a textbook”.

There are a lot of self taught academics out there that have dealt with the same quote unquote documentation problems that you might be dealing with, and thus will be able to offer some great advice and strategies.

But anyways, this is the big one: break it down and interact with the material. Let’s take the Rust book for example. I’m gonna start with this section about generics and ohmygodthat’samassivewalloftext. But hold on; let’s not just read it. Let’s break this down.

An example/usecase 🚩

In this case we’re gonna try summarizing, but this could totally be adapted based on what I’m learning and what I’m doing. And by the way, please don’t use Chat Gippity to summarize – that completely misses the point of what we’re doing.

Ok, first we’re told that generics are abstract tools.

Then we’re told that functions and structs and a few other things can work with generics.

There’s also this tidbit about traits and lifetimes but we’re gonna avoid that for now since it’s not really on topic.

However, it should be noted that if the Rust book includes traits and lifetimes in a section about generics, we might also want to consider how they’re connected.

Anyways, we broke down the problem. Now let’s interact with the material. When it comes to programming languages like this, I tend to enjoy just splatting something out into my editor and seeing if it's anywhere near right. Now you’ve probably seen generics before, but let’s act like you haven’t.

It's not working! 📉

Ok, so I know generics are defined with the little pointy brackets anywhere we want multiple data types to be accepted into a parameter of some kind, so maybe when we define a type in a function parameter we can add a generic… oh that’s not working.

fn my_func(param: <T>) { // ... } 

Let’s pause for a second. This is where we should probably stop, go back to the Rust book, and do what we just did again: break the problem down and interact with the material. Ok, our problem is that we don’t know the correct syntax for generics. Let’s look around… and oh, we just found a sample function definition with generics... and that makes a lot more sense!

Ok, so it looks like we put the generic out here and then just include the type, T in this case, in the function parameter itself. And look at that, it works! (For the nerds in the room, yes, I know this isn’t a complete example (kinda))

fn my_func<T>(param: T) { // ... } 

Hold on 🫷

Now stay with me for a moment. You might say “oh but this doesn’t work for everything” but it does. This works for the documentation of anything – even the country I live in (and no, I’m not joking, you could totally do this with the law).

But look, my point is that you probably haven’t been doing this, but you definitely should be. Don’t just read a bunch of documentation and try to commit it to memory. Actually think about it and interact with it and all that fun stuff.

Bringing it full circle ➰

And let’s bring this full circle. Remember at the start of the post how I noted that you probably can’t recall everything you just consumed and/or read.

I did, trust me!

And if you completely forgot about this, well, that proves my point. And if you didn’t, awesome. But let’s expand this idea to what we just did. Just think for a second, what did we learn about generics in Rust?

Actually learning 🏫

If you said “it's for multiple data types and they go in pointy brackets outside of a function”, great. And don’t worry about the fact that this sounds wildly unorganized. That’s fine.

What actually matters is that you understand it and can actually recall the information that you just absorbed.

There’s a lot of science and psychology behind why this works, and for many reasons I’m not going to cover that on this channel. But if you’d like to know more, I do recommend Benjamin Keep. He makes quite a few very well researched videos on this stuff.

Benjamin Keep, PhD, JD - YouTube

Insights into learning, science, and society. For teachers, students and the science-curious. I’m a cognitive scientist specializing in learning and instruction. I focus on how to develop expert reasoning skills and what the heck this beautiful, fascinating thing called science is. You’ll also find videos on social science research methods and bigger picture stuff, like how social systems produce scientific knowledge and why that knowledge sometimes goes ignored or misapplied. I have a PhD in learning sciences and technology design from Stanford and a law degree from Cornell. You can read more at www.benjaminkeep.com and sign up to my email newsletter there.

youtube.com

Another option 🛗

But hold on, there is actually something else you can do here. If you’re still confused about something that you’re learning, try breaking it down and summarizing it, then building it back up in your own words.

We can do that with our previous statement like so: “Rust generics allow for multiple data types to be handled through a singular function parameter, and the type parameter is defined in the angle brackets outside the function”.

But do what makes you happy and do what makes you comfortable with the documentation that you just read.

Bad documentation 📜

One other thing I wanna address is the following: how do you deal with bad documentation?

This is adamantly the fun part – or, not so fun part, I guess. When you come across bad documentation that’s poorly written or lacks appropriate content, this whole “magical” strategy kinda breaks.

Imagine if I couldn’t quickly find that sample function with generics from the Rust book. I would be dead in the water until I found either an example in the book or an example from relevant source code elsewhere.

And I’m gonna be completely honest here: there’s no one right answer for how to handle atrocious documentation. That being said, I think the best thing to do and the natural response is to take to GitHub issues or the forums and ask a question.

But usually, especially when we’re talking about Linux or some other well used technology, this isn’t a problem. And that’s kinda why I’m not addressing it so heavily.

Oh well. 🤷

So yeah, you’ve probably been reading documentation incorrectly the entire time.

But you might not agree with that, so let me know if you don’t, and let me know how you read documentation.