I’ll spare you the traditional arguments for why you should study and practice what is considered “the fundamentals.”

In Karate, we weren’t allowed to spar until we could strike the punching bag with flawless technique (and block punches instinctively). In Jujitsu, we weren’t allowed to grapple until we had mastered breaking falls and basic throws (takedown techniques).

Half the practice sessions were cardiovascular and footwork exercises that had no apparent relationship to fighting people.

In retrospect, the wisdom behind this constraint is evident: if you go straight into a fight flailing your arms, you won’t learn as efficiently as drilling the fundamentals directly.

Sparring is far more effective if it leverages existing habits than developing techniques from scratch. Having to think about proper technique when another classmate is swinging at you causes the skill to develop more slowly.

Actual sparring is simply the sum of the fundamentals: good footwork, good striking, good blocking, and not running out of breath.

Jumping straight into TensorFlow or solidity will not make you an effective machine learning or blockchain engineer.

Master the fundamentals first and revisit them often.

Wax on, Wax off — Bits in, Bits out

Every problem in computer science, regardless of the domain, is a string of bits going in, some operation happening, and a string of bits going out.

Every. Single. Problem.

The interpretation of these bits is domain-specific, but they are all bit sequence transformations.

There is a science to reasoning about these bit string transformations. It’s called computer science.

this abstraction applies to everything in development.

The state of a blockchain is modeled as a string of bits (everyone’s balances and the state of the smart contracts). You combine that state with another bit string (a transaction), put the two into a transformation, and get a new bit string: the new state of the blockchain.

Machine learning is the same thing. Data + model (both bit strings) result in a new bit string (trained model). In that field, we semantically interpret the Data as “jpegs,” the model as a “network file,” and the transformation as “training,” but they’re still just bit strings and transformations.

Rendering a website is a transformation of JSON from the API to HTML on the webpage. Bit string in, another bit string out. These have a higher level of abstraction than JSON and HTML, but under the hood, the same bit string transformation is happening.

There are basic theorems about what can and cannot be done with those bit string transformations, regardless of domain:

If a bit string is interpreted as computer instructions, will it result in an infinite loop or not? (Undecidable, that’s the halting problem).
If a bit string is interpreted as computer instructions, can we prove it has some equivalence to another bit string? Yes, but this is generally intractable. But if we model it as a constraint solving, we can efficiently solve some cases.
If a bit string is modeled as conveying information, can the bit string be made smaller without any information loss? How do you know when you cannot make it smaller? (This matters for saving bandwidth!)
If a bit string is extremely large, what claims can we make about efficiently retrieving pieces of information we care about it from relevant substrings? (Database theory and distributed systems)
Given one bit string and another bit string, output another bit string that describes their similarity. (Search algorithms)
Or how about if a bit string represents the state of a system? Can it be transitioned to undesirable configurations? (Hacking and state machines).

Reasoning about bit string manipulation makes you good at any specialization in computer science

You aren’t actually moving 1s and 0s around; you are applying powerful abstractions on top of the interpretation of the 1s and 0s

these abstractions are the results of decades of research by some of the most brilliant thinkers in history. You truly get to stand on the shoulders of giants.

These categories of abstraction fall into clusters known as “cryptography,” “information theory,” “compilers,” “networks,” “virtual machines,” and so forth. You know, the subjects that don’t seem worth studying because there is an established tool for them.

Let’s go back to our martial arts analogy. You might see some black belts exhibiting a really impressive sparring match, but under the hood, it’s really just footwork, striking, blocks, and not running out of breath. The same phenomena powers the impressive feats coding ninjas pull off. It’s just the basics fluently executed.

Everything you do in computer science is taking a string of bits that represents something and turning it into another one that represents something else. (Or if you are a hacker, identifying inputs that result in undesirable outputs).

You get better at computer science by improving your general ability to model and transform bit strings, not by writing your 10th NFT minting website.

The more abstractions and paradigms you have at your command for bit string transformation, the more capable you will be in any field of computer science and development.

We require students to pass an easy to medium data structures and algorithms test before they can join the RareSkills blockchain bootcamp

I readily admit it is rather cruel for someone to have to solve data structure questions in 45 minutes with a dry-erase marker

Someone who cannot solve them at all, however, is not a competent programmer and should not be trusted with creating smart contracts holding millions of dollars

data structures and algorithms are an important aspect of the foundations of computer science,

Employers generally know that fundamentals matter more than application intuitively, even if most don’t verbalize it explicitly.

Let’s do some basic math. Let’s say there are 12 frameworks and languages that really matter. An average developer can genuinely master 4 of them in a 5-year career. The probability that the developer learned the same 4 out of the 12 the employer wants is 1 out of 495.

(That’s 4/12 * 3/11 * 2/10 * 1/9 or C(12, 4))

Your chances are 0.2%

To be fair, a lot of software engineers have unrealistic expectations also. Matching software engineers to jobs is as messy as traditional dating

Why does the employer hire people who don’t perfectly meet the job description? (Or, for that matter, why do people date partners who don’t check all the boxes? Sorry, I digress again, but it’s illustrative).

because they can see the developer has generalized skill in computer science and can adapt it to what the company needs

“Generalized ability within a domain that is more specific than just being smart but more general than memorizing a bunch of facts — someone who ‘gets it’ where ‘it’ is a set of important meta-skills that apply to the common relationship between what needs to be solved this week and is likely to need to be solved next month… And when they solve the problem, they understand the side-effects within the domain that accompany the solution, and how those side effects might leak into other domains.”

we do have words like “expert” and “mastery,” but these are very diluted and overused by educators who claim they can bestow “expertise” on you by teaching you how to parlor tricks with whatever framework is hyped today.

“years of experience” being the key factor, right? Employers expect you to understand how the frameworks work, not only how to interface with their APIs.

All frameworks boil down to the fundamentals. They take a bit string you provide through the API and return another bit string as a state change or the result of a query. They are doing the same kind of fundamental data transformations in the foundational domains I listed earlier.

Want to master the frameworks? You know what my next sentence is!

So study the fundamentals, not the frameworks. That’s how you become someone who can learn any framework quickly — even create the frameworks yourself. And that’s what the employers really want, even if the current language doesn’t allow them to express the desire succinctly.

Because “fundamentals” sounds like “beginner” (I.e., you should go into the corner and punch that bag a hundred times before you can practice with people who have a darker belt than you), I’m going to refer to certain computer science concepts as “Evergreen” and “High Leverage”. “Evergreen” because it doesn’t go out of date and “High Leverage” because it accelerates the acquisition of related knowledge

learning how compilers work will help you learn any language faster.

Learning how CPU architectures and machine code operate will help you optimize any smart contract on any blockchain.

Learning another language doesn’t teach you much about compilers. But learning compilers will help you with programming language acquisition. That’s why it’s traditionally referred to as “foundational,” although I prefer to call it “high leverage” in this context.

Learning how data structures and algorithms operate will help you decipher large code bases as you can read the architecture in sensible chunks rather than variable by variable.

having been through the drill of modeling and transforming bit strings in multiple ways, good solutions will come to you faster when you code in the “real world.”

you’ll also understand why frameworks model data the way they do, and it will help you learn new frameworks faster and stay ahead of the competition.

You’ll be out of date a year from now in blockchain, even if you study the current material today. You will always be out of date. The key is to navigate expiring information better than your competitors by equipping yourself to learn faster.

The laws of the universe that govern information encoding and transformation do not go out of date.

Depth-first search is over a century old and is still relevant today. Radix sort (faster than quicksort in many applications) is also a century old. The Turing machine, which underlies all theories of computation, was conceptualized 80 years ago. The assumptions cryptography relies on have not changed either. It boils down to whether the encrypted text (again, a bit string) “appears random” by formal definitions.

Computer science is just the manipulation of bit sequences. Always has been. The rules that govern it are evergreen.

Major innovations are very incremental under the hood. It’s just that the major innovations incremented a couple of critical variables with highly disproportionate outcomes

Staying up to date means quickly grokking how the latest clever guy or gal recombined existing knowledge.

Major innovations are very incremental under the hood

It’s just that the major innovations incremented a couple of critical variables with highly disproportionate outcomes:

Bitcoin merely combined digital signatures with proof of work (both decades-old concepts at bitcoin’s time of invention). Ethereum took Bitcoin’s execution core and made it Turing complete. Chat GPT took the self-attention transformer (4 years old by that point) and made it bigger, and added some hardcoded business rules.

“Innovation” is usually just a serendipitous increment of a key variable with an asymmetric result (in other words, meticulously recombining and improving something until something different and/or good happens).

fundamentally understand what gets incremented when an new innovation rolls out, you’ll master the new technology at a speed that bewilders your contemporaries.

every technology is built from the ground up from the same first principles, just combined differently.

Do something crazy like build a compiler from scratch or implement a nontrivial cryptography algorithm from the mathematics up

One project shows you know how to follow a tutorial. The other demonstrates that you can tackle difficult subjects head-on and can handle the myriad of issues that may come up but don’t appear in the job description.

it’s very hard at the early stage to see the relationship between flipping binary trees recursively and writing efficient smart contracts.

The feeling can be like when I was learning martial arts: “Why are we doing jumping jacks when we should be kicking people in the face? The connection seems so distant!”

more first principles you grasp, the faster you’ll be able to learn in a new subfield of computer science, as you are no longer learning from the ground up. Instead, you are simply combining the information you already know

Fundamentals are a lot broader than just leetcode

it will always be more efficient to study the foundations directly rather than learn through random chance

How to drill the fundamentals — not just leetcode
Learn a useless functional programming language. It will force you to see bit strings in a different way.
Work your way up to leetcode medium in that language
Write a compiler from scratch
Create a simple operating system or virtual machine from scratch or modify an existing one
Learn complexity theory (hint: it’s not only O(f(n)) analysis)
Take a cryptography course and actually re-implement the algorithms
If you are doing machine learning, take a proper linear algebra and statistics class

Everything in computer science is a bit string that goes into some box and comes out as another bit string. You learn that in complexity theory. All of these fields are just ways to apply abstractions and useful interpretations to the bit strings. The more abstractions you know, the more powerful a developer you will be.

Studying material without understanding why it is important is not optimal.

It’s great if you have a teacher who inspires you to have confidence in mastering the first principles, but not everyone has that luxury.

Just starting off → tutorial hell → learning from doing → mastering the fundamentals.

A successful four-year degree CS student might have a learning journey that looks like this:

Mastering the fundamentals → learning from doing → revisiting the fundamentals.

Frameworks go out of date. The fundamental theorems of information encoding and manipulation do not.

Everything we do in software development is a glorified interpretation and transformation of bits.

Bit sequence interpretation and transformation is a skill that can be directly developed with deliberate training. The more fields of computer science you study, the larger the vocabulary you can bring to the problem at hand. The best engineers develop these skills intentionally. The average devs go straight to using the frameworks.

The difference between you and the engineer who earns $100,000 more than you is not a knowledge of a language or framework. It’s knowledge of the components of the framework. And those components depend directly on the foundations of computer science.