For the past two years, I’ve been teaching myself to program and pushing full-stack Web3 builds onto my GitHub. I even built some blockchain data indexing projects with Rust and Substreams powered Subgraphs.

Programming is always a pleasure,

but the real reason I began programming in Web3 was to build a hard skill that would pair with my philosophy degree.

I love philosophy, but being a philosopher as a career is a bit much for me.

But now that I have hard skills and a background in technical writing in
philosophy, I am ready to move to the next step. This step is a career that blends philosophy’s subjective nature with code’s objective nature.

Something like… Developer Relations!

I applied for this free exclusive course that, to my surprise, featured guest speakers who were people I had been watching for a long time on YouTube.

In this article, I’m honored to share the main things I’ve learned from each speaker in each class.

Lesson 1: Getting Situated (30–60–90 Plan)

When hired, you’ll want a plan for attacking your task of
being a DevRel. The best thing to do in the first 30 days is to study the company you work for.

What is the culture, how does the product work, and who uses it?

What kinds of people are shareholders, is the documentation up to date, and what is the voice and tone of marketing?

Studying these will help you fit in and align with the company’s mission.

From the 30-day mark to the 60-day mark, you’re done treading the shallows and ready to dive deep.

Go through your company’s and competitor’s code examples. Which is better? Shouldn’t be your competitors after you’re done with changing a few things.

For 90 days and out, you are situated. You know your team, the culture, the
documentation, the product, and everything that goes into representing a company.

Lesson 2: Bootstrapping DevRel? Sounds like a trip

Bootstrapping sounds super exciting. Imagine getting hired by a company that has no DevRels.

This means you get to do everything and set the standard for the future. Steph Orpilla gave a fantastic presentation about how she bootstrapped DevRel at Nillion.

She talked about the importance of not putting the wagon before the horse.

This expression symbolizes that nice things should not be prioritized above the required things. In DevRel terms, it means you must put on your developer hat and write documentation, code examples, and open communication channels with users.

Nothing matters if these bases aren’t covered.

Lesson 3: Why Developers Hate Docs

My main takeaway from Patrick Collin’s presentation is an article he wrote: “Why developers don’t like docs”.

I understood from the read that documentation doesn’t inspire people to do anything cool.

It makes me want to leave my computer and do something else.

Documentation should be something people refer to in the event they need something specific. It should NOT be the sole source of information about the technology.

I’ve worked with very niche tools like this, and it sucks.

Not the tools, just the developer experience.

So what should you do if people hate docs? Give them an alternative… a challenge! A guide that forces them to think and explore what your company has to offer.

A good challenge should drive their curiosity and let them uncover features, all while being guided through a project.

Imagine if video games, instead of having a tutorial section at the start of the game, had an instruction booklet for what buttons to press.

Yeah, hopefully, that stays in our imagination.

Lesson 4: Give People Money

Now, I’m super biased about this lesson. However, the strongest thing that kept me learning and building in Web3 was a stream of ETH from the BuildGuild founded by Austin Griffith, who was also the speaker for this lesson.

I knew that if I could program well enough to make contributions to Scaffold-ETH, I had my foot in the door as a certified Web3 engineer. After a year, I was part of the BuildGuild, making contributions, prototyping dApps, and improving the developer experience.

I asked Austin during the lesson how he got Scaffold-ETH (check it out if you don’t know about it, I’ll shill it till I die) to reach so many people.

He said, “Give people money”. If people build with your technology in good faith and are rewarded with money, many people will be building with your technology.

It’s actually within the BuildGuild that I discovered my passion for developer relations.

Lesson 5: Bridge Builder

I was traveling and unable to attend this class by Nader Dabit, but I read a blog post related to this class.

In the blog was an old poem I memorized in college: Bridge Builder. Of course, as a college student who was here to party, this poem was corny, long, and annoying. But now that I don’t have to memorize it,

I can fully appreciate the poem’s pacing, rhyming, and message.

Bridge Builder is about an old man who crosses a big chasm with little effort. The chasm never bothered him because he was experienced. He begins to build a bridge across the chasm, and a young man approaches and asks him why he’s wasting what little time he has left on this earth building where he’ll never walk again. The old man explains that this chasm was easy to cross for him but not for fair-haired youths. So he’s building a bridge for them.

Beautifully put, elegant, and wholesome, Bridge Builder is about getting people to where you’re at with less pain.

Lesson 6: Treating your Docs as your Product

The final lesson I learned was from Michiel Mulders.

Your docs are also your product because they are an extension of your product.

With docs (including tutorials, examples, and how-to guides), your product is more useful than what people can figure out what to do with it. At that point, people will choose another product they can use more easily and efficiently.

Wrapping up

DevRel Uni has been a great experience, and I’m honored to have been part of it. I learned a lot, gained clarity on where I want to take my career, and I’m ready to start taking action.

So far, I’m helping make documentation for Edge and Node, Streamingfast, and Scaffold-ETH.

I worked closely with a friend to make a substreams powered subgraph challenge, and I’m testing and adding features to a collaborative project between Edge and Node and Scaffold-ETH. Thanks for reading!

Click HERE to build a Substreams now!

The problem my friend Ben and I had learning Substreams was the need for more tutorials and explanations.

Is it because Substreams are new? Are they too niche?

Of course, Substreams have documentation, but not in the way React or Next.js has “documentation.”

“What’s the problem? Just read the docs. Everything is in the docs.”

Well, yes, technically.

However, things need more than just documentation to become widely adopted. Patrick Collins wrote a fantastic article titled “Why Don’t Developers Like Documentation,” inspired by the book “Why Don’t Students Like School” by Daniel T. Willingham.

In summary, documentation is just that: documentation.

It doesn’t invoke curiosity, promote exploration, or provide a call to action
for developers to try the technology out.

The result is that the inaccessibility of the technology turns away all but the most determined individuals.

The Goal

The goal of new technologies (aside from being the solution to a problem)
is to become widely adopted.

“But how does a technology become widely adopted?”

Let’s step back and consider the precursor to adoption: teaching. “Is documentation teaching?” you might ask. Teaching is about lowering the friction between where someone is and where they want to be.

So what is it in teaching that lowers friction?

Well, as previously mentioned, they’re the things that documentation lacks: the invocation of curiosity, the promotion of exploration, and a
call to action (besides a quick-start section).

This line of thought is just the long way of saying that documentation is not enough.

What to do about it

Now, I love Substreams. As a freelance Web3 builder/writer/dev rel with no job obligations, I can spend time learning and promoting genuinely cool technologies.

I won’t go into why Substreams are cool here, but I want people to use them more.

There are many unconventional use cases for Substreams, too, in addition to conventional ones. That’s what made my inner hacker so determined to learn.

My friends and I centered our entire hackathon project at ETH Denver around unconventional use cases for Substreams, and we have many more ideas on the way.

But I think cold hard determination or a specific use-case shouldn’t be required to learn Substreams.

Since learning Substreams and having a few under my belt, I’ve wanted to make them more accessible to people. Recently, an opportunity opened for my friend Ben and I to do so.

We’ve created a Substreams Challenge!

Why not a simple tutorial? We figured people could check the docs if they want to know something about Substreams.

If people want to build Substreams, they’ll need a thinking framework. And that’s precisely what our challenge aims to provide.

We lay the grounds for curiosity by instructing users through the rigid portions of Substreams (the ABI, Makefile, .proto, and .yaml).

When users get into their first map modules, we equip them with the substreams-ethereum library to explore the different kinds of data they can fetch from the block.

Our challenge has something particular in mind.

While users explore the library for what we need them to find, perhaps making a few happy mistakes, they see for themselves what’s possible.

The same applies to building the store module. Builders receive the tools, requirements, and goals.

The rest is up to them.

We also show them how to check their Substreams output so they can log and debug their way through any issues.

Of course, we also show them what their output should look like so they know they’re on the right path.

What do they get out of this?

When users complete the challenge, they will understand how to set up Substreams, from inputting their ABI to deploying their Subgraph and everything in between.

As a bonus, we also show them how to query their Subgraph from the front end to give them that final dopamine hit of actually seeing their hard labor on a UI.

They will also have built their own Substreams (with a bit of guidance), which they can refer back to as they build new ones.

Of course, concepts are also better remembered because they found the answer themselves.

Personally, I find it a lot more rewarding to complete a challenge than a tutorial because it’s something you can be proud of.

Builders aren’t on their own, either.

We’ve linked them to the Streamingfast discord for questions that still need to be answered not in our challenge or the docs.

We’ve also created a Telegram channel for questions specific to our challenge.

If you’re an experienced Substreams developer or someone curious about Substreams, check out the challenge.

Feedback is needed, because at the end of the day, we’re trying to build something people love, not something people like.

Click HERE to begin!

In this article we will cover

• An example
• Why the technique behind the example works
• Why anyone can have photographic memory
• A caveat and my solution

Let’s start with an example to show you what your brain is capable of. Read the following, and your brain will trick itself into remembering the definition of a word.

Of course, the magic is that this technique can be used for anything!

The Example

Carbohydrate (n.)

A compound made up of carbon, hydrogen, and oxygen atoms; major source of
energy for the human body. — from Quizlet

Carbohydrate (the word)

Split the word into two pictures: car and hydrate.

Imagine a car standing on its back two tires at a gas station, using its front two tires to unscrew a water bottle and chugging it through the front grill like a thirsty jogger. The car is hydrating.

Crazy right? The crazier, the better you will remember!

Carbohydrate (the definition)

A compound made up of carbon, hydrogen, and oxygen atoms; major source of energy for the human body.

(1) Carbon — We can split carbon into car and bon. Think of bonbons, the candy. In French, bonbon translates to good good because candy is good!

So car-bon is good for the car, which we can tie into our car hydrating because hydration is good. And the word carbon is in carbohydrates, so we create even more connections.

(2) Hydrogen — Now split hydrogen into high and gen (as in the prefix of generating). Hydrogen is also in carbohydrate.

Picture a big pothead getting high in the car, generating lots of thick white smoke. You can barely see him, and the smell is loud.

(3) Oxygen

Now the smoke is so thick the pothead is having a coughing fit due to the lack of oxygen in the car!

(4) Major source of energy for the human body

After the coughing fit, the pothead’s mouth is parched, so he grabs an energy drink out of his back seat to quench the thirst of his human body.

Tie it all together into a nice package

Do you think that was a lot to remember for a short definition? Check this out:

• Car drinks water
• Pothead smokes
• Pothead coughs
• Pothead drinks energy

Your brain just played the gist of the story in your head in a few seconds. Now I won’t put bullet points and ask you to play it again in your head… you’re even faster now.

Here’s a revised story to tie it together, and next we’ll talk about why this technique works FAR better than endlessly flipping through flashcards or just blanking out on a test or at work.

A car rolls up to a gas station and hydrates (carbohydrate) on its hind wheels. Liquid is good/bon for the car (carbon). In the car a pothead smokes, getting high and generating smoke (hydrogen). So much smoke there’s no more oxygen causing him to cough. Thirsty, he chugs an energy drink (energy for the human body).

Now when I ask you the definition of carbohydrate at the end, you’ll remember it without having “studying” the definition, and with minimal effort.

Why this works

I discovered this technique in Kevin Horsely’s book “Unlimited Memory”.

It sounded woo-woo, until I tried it in my own life.

If you skipped to this part I implore you to go through the example. This article is not worth reading otherwise.

• Why do we easily recall information from our personal lives, books, and movies?
• Why do we struggle to recall information for school and work?

Sight is our primary sense. We remember images, stories, and narratives because that medium of information is what kept our ancestors alive.

• What bushes have poison berries versus edible berries — image
• The migratory patterns of bison — story
• Tribal conflicts — narrative

Our brains did not evolve to remember why certain berries were poisonous. That was later during the scientific revolution. A person who knows why but can’t see what berries are poisonous is as good as dead.

Our brains did not evolve to explain migratory patterns of bison, brains evolved to know what those patterns were. Again, a tribe member who explains why the bison are migrating is useless compared to a member who knows where the bison are migrating.

When we tie non-survival dependent information (like the definition of a carbohydrate) into a medium our brains evolved to remember (images, stories, and narratives), our memory becomes limitless.

Why anyone can have photographic memory

Kevin Horsely talks in his book about how to create your own stories for information YOU want to remember. The biggest takeaway is the SEE principal. All it takes is creativity. The more you employ the SEE principal, the better information will stick. I’ll demonstrate how I used the principal in my story about carbohydrates.

S — Sense

When you engage your five senses, information will stick better because we are linking it to your physical body. I talked about the smell of the pothead, a hard to forget smell right? I could have also talked about the feeling of the warm humid night air, the taste of gasoline in the air, the sound of the old car pulling up… immerse yourself in the story and your lizard brain will thank you.

E — Energize

Make your images move! A picture is worth a thousand words, and movement is worth a thousand pictures. The car rolls up, the pothead sparks up his joint, blows out the smoke, and begins coughing like mad. Bring the story to life!

E — Exaggerate

Why do people love talking about that crazy time they did XYZ? Because it’s out of the norm, it’s exciting, it’s maybe even a little… exaggerated. But you remember your crazy stories right? You remember other’s crazy stories? It’s because it deviates from normal mundane information. The car standing up on its rear tires and drinking water?

Ridiculous. Impossible. Exaggerated.

Anyone can break down arbitrary words and their definitions (whose only purpose is passing an exam or jargon important for work) into separate components to make a story out of.

And you don’t need to remember the story verbatim, or obsess about every detail. Your brain fills in the blanks. When the occasion for memory recall presents itself, your brain will remember the important parts. The story is just like a sticky bug trap, it makes what you want to stick onto it stick onto it.

Details in the story add more sticking power, they do not take away from your ability to remember what is actually important. That is the beauty of the technique.

The Caveat

Ok, so why isn’t everyone just using this cheat code and getting A’s on all exams without technically cheating?

Breaking down words and definitions to create a story takes time, creativity, and effort.

The process is not frictionless. I don’t believe the argument that you might actually be better off using tools like Quizlet or flashcards due to the effort it takes to create these stories, but the argument can be made.

My Solution

I’ll do it for you. As you’re reading this I’m creating a repository of pre-written vocabulary words along with their definitions, tied into a story that makes these definitions hard to forget. All you have to do is read.

And I promise you will spend a fraction of the time reading these micro stories than you would endlessly flipping through flashcards trying to memorize in an outdated and unnatural manner.

In Conclusion

What’s the definition of a carbohydrate? Or rather as you’d see it on a test, what three elements make up the compound? What does the compound provide for the human body?

Whether you know it or not, your brain always thinks about models. Sports Illust…

Today, we are talking about conceptual models for learning and problem-solving. Think about a topic familiar to you. Now, think about the most important things to understand about the topic and the subtopics within.

What you just thought of is a model for how the information is structured in your brain.

In this article, we will explore how we subconsciously build models of topics and try to bring the process to our conscious mind so we can learn and problem-solve better.

Building new models

When you understand a topic, it’s easier to add and remember new information related to it. Your base understanding has “pegs” that new information can clip onto.

But when learning something new, where do we start? Let’s explore an example by touring a train museum.

Imagine you know nothing about trains and are visiting a train museum to learn about them. At the front of the museum is a big panel explaining steam-powered locomotion.

The panel is full of information (words, sentences, paragraphs) structured so that each piece of information builds off the previous one. When you’re done reading the panel, you have a basic understanding of how locomotives use steam to drive them forward.

Without understanding anything beyond what is written on the panel, you have created an axiom for yourself.

An axiom is a statement or proposition accepted as true without requiring proof.

The axiom is given to you by an authority (a train museum), so your brain makes assumptions about chemistry, physics, and metaphysics to integrate the axiom into your general understanding of the world.

As you progress through the museum, you gather more bits and pieces of information.

Some panels make sense, others seem contradictory, and others make no sense to you.

The more you learn, contradictions sort themselves out, and things that made no sense, now make sense.

The big panel at the start was the base understanding, and having gathered
more detailed information, you built a model on top of that base understanding.

Information is to Legos as a Model is to Lego Set

Think of bits and pieces of information at the train museum as little Lego pieces, and think of the starting panel as a big Lego piece.

The flow of the museum represents a Lego set’s instruction manual, and the whole museum is the completed Lego set.

Building a model is like assembling a Lego set. Some pieces fit (relations) and some don’t (contradictions).

Models vary in complexity, from basic math to auto mechanics to software development.

Lego sets also vary in complexity, so let’s explore how different sets and models are built according to their complexity.

- Basic models

Basic models and sets have a few big pieces (axioms) on which other pieces are placed. There aren’t a lot of parts, so pieces can fit on top of each other comfortably. You might not even need instructions to build the model.

For example, making a new salad recipe. You see the salad and want to recreate it at home. You get the ingredients, chop them up, make a dressing, and toss everything together!

- Complex models

More complex models still have big pieces but are differentiated by the presence of big aggregated pieces.

These aggregate pieces are composed of smaller pieces that give rise to emergent properties to the aggregate piece. Aggregate pieces fit into other aggregate pieces or can be placed onto big individual pieces.

Complex models/sets are harder to build and understand because pieces don’t fit on top of each other comfortably as they do in basic models.

Instead, certain pieces need to be assembled into an aggregate piece, and
only then can the set be completed.

Building these models is challenging without instruction because it’s not apparent which pieces are axioms, where aggregate pieces start and end, and what the purposes of the remaining pieces are.

Building a model understanding in 5 steps

1. Identify the problem the model will solve

Without a problem in mind, your model won’t have scaffolding to guide its construction, and the following steps will be harder to complete.

The problem you are solving will determine the required complexity of the model. If the problem is a quick fix for something, your model should not be too complicated.

However, if your problem requires a lot of detailed knowledge, you should
build a well-architectured and detailed model.

You’ll generally want your models as simple as possible, but no simpler. An Occam’s Razor of sorts. If you are building a model for fun, pursue pieces of information that entertain you.

2. Identify axioms

Figure out what the most important pieces are on the topic. If a topic is unfamiliar, read a general overview about it.

Then, remove pieces of information until the model collapses.

The last piece you removed was an axiom. Restart this process until there is nothing left but axioms.

A Lego set is incomplete without the smaller decorative pieces, but there would not be a Lego set if it were not for the big pieces at the core of the set.

3. Identify aggregate pieces (hardest part)

After trimming fat from the general overview, you might find that some big pieces are aggregations of smaller ones. There is a trap here where the Lego analogy differs from conceptual model building.

With Lego sets, it’s easy to identify big individual pieces from aggregate pieces.

However, in learning, any central concept can be disaggregated into smaller pieces of information by a process called reductionism.

Take the train museum’s first introductory panel about steam-powered locomotion. We can further break the panel down into thermodynamics, fluid mechanics, mechanical engineering, etc. How do we know to what degree an “axiom” needs to be disaggregated?

When identifying aggregate pieces of information, we look for the point where the information yielded by breaking a concept down no longer has any relation to other bits of information within the system.

Imagine the train museum is less about engineering and more about history.

After reading the big introductory panel,

if the rest of the museum is about the differences between cars for transporting cattle, corn, and circuses, there is no need to break the introductory panel down because thermodynamics, fluid mechanics, and the lot have no practical relation to cows, corn, and circuses.

On the other hand, if the train museum was about engineering, it would be worth breaking down the panel because other parts of the museum would have information related to engineering concepts.

Depending on your use case or the problem your model solves, certain core concepts will be whole pieces (called a black box), while others will need to be aggregate pieces.

In Lego terms, big individual pieces are crucial for building on top of and have few points of contact with other pieces.

On the other hand, aggregate pieces have more points of contact with other bricks for building underneath, on the sides, and on top of.

When building conceptual models, the trap is misidentifying aggregate pieces as whole pieces, causing new pieces being added to seem irrelevant or not have any place to connect, or misidentifying whole pieces as
aggregate pieces, causing an over complication of the model and having unrelated information to the purpose of the model.

The takeaway is that your problem will serve as the instruction manual for
which pieces are whole or aggregate.

4. Identify the small decorative pieces

At what point is a Lego set complete? Is a Lego Star Wars X-wing Starfighter still an X-wing if it’s missing a few decorative pieces?

Probably. But what if it’s missing most of its decorative pieces?

A model is only useful insofar as it helps us solve a problem, and if the model is generic, then we won’t be able to solve interesting or cutting-edge
problems.

Decorative Lego pieces are synonymous with the nuanced pieces of information in our models that makes them useful.

How can we identify small, non-essential bits of information?

After identifying big pieces and aggregate pieces, any leftovers are the
decorative pieces. These pieces allow you to build your model in the right shape to solve your problem.

Think of these pieces as any non-knife tool on a Swiss army knife.

5. Build the model

Now, you have separated your individual Lego bricks (bits of information) into three piles.

A pile of big pieces, small pieces that will later be combined into however
many aggregate pieces, and another pile of small decorative pieces to build the Lego set to completion.

To build your model, start by understanding the purpose of the big pieces.

• Why does the model fall apart without them?
• How are the big pieces related to each other, if at all?
• Where do they connect?

Ask yourself these same questions about the soon-to-be aggregated small pieces.

Asking these questions about all your pieces is how you build your model.

Aggregate pieces should be built individually so that relations between the information pieces are clear.

Then, combine the aggregate pieces if there are relations between them or place them directly on the big pieces if the aggregate pieces have no relation to each other.

Finally, add the decorative information to fill
the gaps or add functionality between the model and the real world.

The more models you build, the easier it will be to build more models

What do polyglots, computer programmers, musicians, and polymaths all have in common?

They all have great conceptual models of their craft.

They also have an easier time adding decor to their models because the big and aggregate pieces are already built.

Someone who speaks several languages will have an easier time learning new ones. A musician’s second instrument is learned faster than their first. After learning JavaScript, python comes more easily.

Johann Wolfgang von Goethe not only has a sick name, but he was an author, playwright, botanist, physicist, important government official, philosopher, musician, linguist, and a true polymath in every sense of the term.

Whether he knew it or not, his scaffolding for model building was so strong that he enabled himself to solve cutting-edge problems in many unrelated disciplines within one lifetime.

Modeling information is the key to being an intellectual powerhouse, a jack of all trades, and a master of all.

At some point, we all felt disillusioned with school.

• Q: How did this teacher get hired?
• A: They are a good researcher.
• Q: Why do I need to know this information?
• A: You don’t.
• Q: Why did I just go into debt to ask how this teacher got hired, and why do I need to know this information?
• A: Allahu ‘alam

Enter the mass disillusionment with the college system. But where did this disillusionment come from? From a broad point of view, it’s due to the coming of the information age.

People born after 2000 had internet disposal as soon as school got challenging.

• Did the teacher not explain something well?
• Did you forget a concept in the lesson?
• Do you need it repeated a few more times?

Just google it. We have been educating ourselves through the Internet
to the point where school is just a middleman, accountability tool, or guideline.

My greatest disillusionment came from realizing that people on the Internet teach much better than people in schools. Bad teachers in the school system are everywhere. In contrast, bad teachers on the Internet are almost never found because they don’t gain an audience. The Internet platforms teachers based on merit instead of necessity, scarcity and research quality.

Why not cut out the middle man?

Schools have the keys of the gate to our desired professions.

From the people I’ve met since graduating, I’ve gathered they use between 0–20% of the skills and knowledge acquired from college in their day-to-day work. The middleman is not so useless in that he offers access to careers, but not access to skills in those careers.

A prime example is an old coworker about the same age as me. We were hired simultaneously at a company that designs and produces scientific tools that use laser beams (spectrometers).

He had a master’s degree in photonics (the study of light) while I, on the other hand, was completing my philosophy degree at the time. We were trained together and worked on similar things, and after two months, he was fired.

The boss later told me, and I quote: “He was useless.” Over time, the company proceeded to fire several PhDs because the return on a college-educated employee was not worth paying their high salary.

What does this mean? Companies don’t care about your education. They care about your competence.

A company with “uneducated” competent workers will steamroll a company with educated incompetent workers because competence implies education, while education does not imply competence.

Plus, it’s a lot cheaper. Feel the disillusionment settling in?

What about business bros and communications sorority girls? Would they become more competent by practicing real business skills and real communication skills? Or by taking a college class about it? College breeds incompetence because it gives a false sense competence, and has people focusing on the wrong things.

The disillusionment comes from jobs demanding skills never taught in school.

1. Learn a subset of Rust
2. Learn about how the blockchain works under the hood
3. Learn how substreams work
4. Learn the libraries that allow you to build substreams

The first I heard of substreams, my friend was telling me about how I could make 20 grand writing substreams. Of course, writing substreams doesn’t just get you 20 grand.

People aren’t just going to throw money at you for writing a substreams. You didn’t actually think that, did you? Well, at the time, that’s exactly what I thought.

I’m a freelance programmer who hasn’t YET broken into the scene, so throw the word 20 grand my way, and I’ll learn Rust and a new technology I have no understanding of or what any of the use cases may be. That was at the time, of course.

Now it all makes sense, and I’m writing to tell you about substreams, how I got into them, and how YOU can get into them (and maybe make 20 grand).

1. Learn a super easy language called Rust

Honestly, Rust is not that bad. Substreams are written in Rust, specifically, a particular subset of Rust. This means that you don’t even have to learn all the facets and quirks of the language. Although the facets and quirks are what make it a pleasure to work with.

Substreams already have a structure you don’t have to deviate from and get all engineered up about. Once you understand substreams, the Rust will flow. Most of my challenges have come from a lack of understanding of the EVM rather than a lack of Rust understanding.

I “learned” Rust in about two weeks with my other friend who hopped on the substreams train. For reference, I’m a self-taught programmer. I graduated with a philosophy degree, which has nothing to do with programming until you reach the depth where computation intersects with logic (a based branch of philosophy).

I’ve been programming for a bit over a year, covering all the front-end goodies, python, and solidity. I’ve also dabbled with some emacs lisp. My friend and I sat on our couch, put on our programmer socks, and read the most essential chapters from The Book.

What book? The Rust book should be the first thing if you google it.
After a week and a half boom, we had the time of our lives writing substreams. At the time, I still had no idea what they were for, really.

2. Learn what data looks like on the blockchain

You cannot write a single line of substreams Rust if you don’t know how the blockchain works under the hood. This was a very bizarre step for me because you are learning how the blockchain works under the hood from the perspective of a Rust library you will use to build substreams.

I’ll keep this part short because I got stuck in tutorial hell learning “how the blockchain works” instead of just writing substreams and having questions arise as I wrote them. My biggest tip is not to focus on “learning the blockchain.”

Instead, focus on becoming an Etherscan expert. I spent so much time looking at addresses, transactions to and from those addresses, logs, contracts, OPcodes, topics, and almost as far as the rabbit hole goes. Exploring Etherscan realistically helped me 1,000,000,000 times more than explanation on the internet. Etherscan is your friend, and YouTube is the enemy of this step.

This step is like when boomers brag about having to read encyclopedias at the library if they want to find something out. Welcome to the 1970s, where the amount of information about substreams on the internet is limited to the docs, RTFM, and a tech demo video at an ETH conference.

Funny story:

When I was researching substreams on YouTube the first thing that popped up was my friend who originally shilled me giving a talk about them. That’s how little information exists about them, I found my childhood friend explaining them on YouTube. That being said I watched it 3 times because its very thorough, informative, and is just an amazing talk overall.

Here is it: https://www.youtube.com/watch?v=fogh2D-vpzg&t=2119s

You are all alone… just kidding, I’m here, and StreamingFast (the company that created substreams) has a Discord server with amazing people. The Graph Builders DAO Discord server is also highly recommended.

I wish there was some tutorial, voice, or someone explaining how to write substreams simplistically, so I could ask better questions to the experts in those chats. I decided to do it myself, because I have the time and I went through the pain. There is a stark difference between explaining a concept, and explaining HOW TO do said concept.

There’s information about substreams, but absolutely no information about how to actually write one step by step. In a future post, I’ll break it down. This is just an intro post, so you’ll trust me. Trust me bro (or dudette).

3. Learn what substreams are

I won’t say anything about this because that’s their only information: what substreams are, how they work, and what they are made of. I won’t waste my carpal tunnel fuse on what substreams are except for a brief analogy.

Substreams are like a stream of water full of different microscopic metals. The stream eventually dumps into a lake. The lake represents either a database or a subgraph. Your job as a substreams developer is to filter the metals (the data) and transmute (Jungian and pre-scientific alchemy connoisseurs will get this reference) the metals into your desired quantity, and desired alloy.

In substreams language, this means filtering data with map modules and aggregating the data with store modules. There is a surplus of this information in the docs. Map modules can’t hold data. They only filter data. Store modules aggregate data and should be thought of as a hashmap, map, object, or struct, depending on what languages you are familiar with.

The point of substreams (yes, they’re plural for some reason) is to populate a database at insane speeds. You can get data practically in real-time. That data is fresh off the block. I’ll let the docs and other resources explain in better detail, but substreams are lit, no question.

4. Learn how to use substreams libraries

You can brag to boomers about how these libraries are way harder to find what you need than their neatly organized libraries from their childhoods.

Maybe I’m dumb or don’t understand Rust, but this was the most challenging and least exciting part for me. Substreams Rust is different from normal Rust as we previously covered. It’s like Rust was implemented around substreams rather than the other way around.

“Rust is simply a medium through which the idea is expressed.”

— Myself

The library section deserves a whole article so I can break it down
properly. Basically, the data you are looking for and things you want to filter against are layered in a bunch of structs that return various things you need to manage appropriately.

Summary

To conclude this article, substreams are lit. Learn them, and someone might give you 20 grand. This is financial advice (not really; I’m not sure if I’m allowed to make that kind of joke, but if I tell you I’m joking the joke is less funny). My goal here is to help you all build substreams and explain them in a non-technical sense so that developing them is more accessible.

Do you ever learn something complex and realize you don’t know how to do the thing you just learned? Is it because you don’t remember how or because you have not practiced doing that thing enough?

Sometimes, even after hours of working away at a problem, you don’t understand what you don’t understand.

You try something the way you learned, and it doesn’t work. So you try it your way; it works, but you just can’t explain it. Or you get creative and try something the way you think it works but fails without a clear cause of failure.

I’ve had endless frustration with this feedback loop of referring to examples and documentation and trying it out only to have it fail. Leaving me frustrated at the documentation and myself.

If you think you need to practice more, you might end up practicing the wrong way.

Training yourself the wrong way is detrimental because your future self will need to unlearn the training and habits you built up. So now you are fumbling through the problem, getting bits and pieces.

Still, the solution is wrong or at best messy, because there was no context
or information about the problem or knowledge of previous, more efficient solutions.

Now, a different version of you thinks you need more information and knowledge about the problem at hand. You hit the books and learn voraciously. All of this information will surely help solve the problem.

All you need is more context to understand the problem right? Let’s say you have the context and information now, to solve the problem. The problem is still staring you in the face, and you have no idea where to start.

The longer you stare and think about the problem, the more you forget the context and information about the problem you just learned.

The solution to this churning issue of practice and context is understanding the difference between skill and knowledge. To isolate skill from knowledge, let’s walk through an example of a non-complex task, such as changing a lightbulb.

Two people will handle the task, Mr. Skill and Mr. Knowledge.

Mr. Skill only has skills for changing a lightbulb and no knowledge of lightbulb sizes, voltages, or colors. Mr. Knowledge knows everything there is to know about lightbulbs but has no skill in performing the task.

Mr. Skill gets the lightbulb supplies, looks at the lightbulb, immediately begins to fiddle around with it. He tries screwing in the wrong-sized lightbulb and later flawlessly screws in the right-sized wrong-type of
lightbulb.

Meanwhile, Mr. Knowledge has the supplies and stares at the broken lightbulb, knowing everything about the metals, the volts, and the physics,
but no practice at a lightbulb changing procedure.

Neither a surplus of knowledge nor a high amount of skill alone
can solve the problem. The gap must be bridged!

• Skill is acquired through practice
• Knowledge is acquired through memorization

To solve your problem, you need the right amount of skill paired with the right amount of knowledge. Understanding if the problem you can’t solve is due to a knowledge or skill gap is critical. How can you tell if you are experiencing a skill or knowledge gap?

If you are comfortable navigating the problem and the problem feels familiar, you are probably experiencing a knowledge gap. You have the skill and practice, but without more knowledge and context, solving the problem can result in a arduous over engineered solution.

Go read about the problem. Read about what you need to solve the problem at this given moment. No more and no less, lest you end up in tutorial hell.

If you are comfortable explaining what different components in your problem are doing, or if you can reason about the problem and know the desired outcome, you have a skill gap.

You have context, but you need to practice more to articulate your
solution. You must scale down the problem to practice the smaller components and build your way to the final solution.

You have the knowledge to find the solution, but you need to practice the skill on manageable chunks of information to arrive at the solution.

So, when learning about a complex topic, how do you acquire minimum viable knowledge to start building minimal viable skills?

In order to then, move back to minimal knowledge acquisition to keep building minimal skill again. Or vice versa, develop minimal viable skill to find out what knowledge you’re missing, to ask the question that will return minimal viable knowledge.

Either way is acceptable, but significant gaps between skill acquisition and knowledge acquisition are a sure way to frustration or suboptimal learning. Learning is hard, why make it harder than it needs to be?

So what is the best way to keep the gap between knowledge and skill from getting too wide? Well, there’s no answer because every field is different.

However, being acutely aware of the distinction between skill and knowledge helps you diagnose your learning troubles.

Remember, identify if the problem you are facing is due to a skill or knowledge gap, then fill the gap accordingly! The purpose of this article is to just bring awareness to this discrepancy in learning.

If you start at the wrong place, you might be in over your head and start
building misconceptions about how blockchains work. Or worse, you
might be pin balled around different courses, stuck in “tutorial
hell.” Not knowing where to start can lead to decision paralysis or wasted time.

When I started my web3 journey, I was lucky to have already been
connected with a few of the most important learning resources. A community. A set of programming challenges. And scaffolding. When I joined the Scaffold-Eth-2 community, I entered a fold of builders building all sorts of dApps using technologies from all reaches of the web3 space.

These builders were the most welcoming and helpful people I’ve came across on the internet. After a week in the community, I realized the best way to learn about blockchains is to build, test, and play with blockchains.

I went through Scaffold-Eth’s programming challenges called Speed Run Ethereum. In these challenges, you focus on building smart contracts. You develop skills and learn design patterns, instead of getting an information dump from tutorials where you’re left with a lot of “knowledge” and a blank cursor in front of your screen.

I learned through building instead of memorizing. Before even finishing the challenges, I was already building my own decentralized application. I was eager to use my skills to realize the projects I wanted to create. I built a dynamic debt managing dApp to use among friends, and a DAO where members can propose and vote on chores in a communal living space. I built tools that were useful to me.

Scaffold-Eth is a repository on Git Hub. There’s a smart contract that serves as scaffolding for what you want to build, and a template front-end all running locally on your machine. It’s not a closed-off sandbox website. It’s part of the open ocean.

You have the repository on your machine with organized folders that keep you focused on your smart contract. When you’re done with the smart contract, there is a folder for you to build a front end. When everything is finalized, you can deploy your contract on a real blockchain and put your front end on a live URL in 2 minutes.

Go to Scaffold-Eth, go to Speed Run Ethereum, and join the many telegram chats where experts help guide you through questions and problems you encounter during the journey. I’ll be in the chats, too, answering questions and helping you debug and build. Start your web3 journey at the perfect spot, and remember, there is no better way to learn than to build!