For Those Just Starting

After Reading This

You'll understand why coding is not "studying" but "experiencing." And you'll have already run a few lines of code.

Part 1. We Already Know — How to Learn a Language

Nobody Taught Grammar First

Do you remember the first words you ever heard?

Of course you don't. But one thing is certain — nobody ever said this to you:

"Okay, the basic sentence structure in English is Subject-Verb-Object. First understand this principle, then try speaking."

That never happened.

Your mother just said "mama," and your father said "dada." They didn't explain the meaning. They didn't teach rules. They just repeated. In their own ways, without standards, without grammar. And then one day — we were speaking.

Coding is the same.

Just Follow Along — Your First Code

Look at the code below. Don't try to understand it. Just press the Run button.

print("Hello, World!")

assert "Hello" in "Hello, World!"

Did Hello, World! appear on your screen?

Congratulations. This is essentially the same thing Tim Berners-Lee did in 1991 when he created the world's first website. You told a computer "show this on the screen." Every program in the world, every app, every website — started from this single line.

Simple? Yes. And that's exactly the point.

Saying Hello in Our Field's Language

This time, let's try something familiar to us. Just press Run.

dna = "ATGCGATCG"
print(f"Sequence: {dna}")
print(f"Length: {len(dna)}bp")

assert len(dna) == 9

We attached a label called dna and stored the sequence "ATGCGATCG" in it. len() is a ruler that measures length. Just as we measure band sizes on a gel, the computer measures the length of a sequence.

If there are parts you don't understand, that's perfectly fine. For now, just think "Oh, so this is possible" and move on.

A Computer Is a Calculator — Just a Very Fast One

You grab a calculator when you need to figure out dilution factors in the lab, right? A computer is that calculator. Just a bit faster.

stock = 10.0
target = 2.0
dilution_factor = stock / target
print(f"Dilution factor: {dilution_factor}x")
print(f"Dilute the 10 mg/mL stock {dilution_factor}x to get {target} mg/mL")

assert dilution_factor == 5.0

stock / target — that's all there is to it. Division. Computer scientists built the underlying logic, and we just use it. We're not trying to invent a new programming language. We're using existing tools for our research.

Processing Multiple Samples at Once

Just as you load samples one by one into a 96-well plate, you can give the computer multiple items at once. Just press Run.

samples = ["Sample_A", "Sample_B", "Sample_C", "Sample_D"]

for sample in samples:
    print(f"{sample} → Analyzing...")

print(f"\nTotal {len(samples)} samples processed!")

assert len(samples) == 4

You don't need to know what for means. Right now, just feeling "Oh, I can run multiple things at once" is enough. You can look up the grammar later when you get curious. Little by little, like looking up words in a dictionary.

Call Its Name and It Says Hello

name = "Dr. Kim"
lab = "Genomics Lab"

print(f"Hello, {name} from the {lab}!")
print(f"Welcome to DevBench.")
print(f"From today, {name} is a coding researcher too.")

assert "Dr. Kim" in f"{name}"

Try changing name to your own name and press Run again. The computer greets you.

Why This Approach Works

How many times have you pressed Run so far?

You probably didn't understand most of it. What print does, what f"" means, what for is. That's normal. No — that's correct.

Here's the flow we're aiming for:

1. Just follow along — it's okay not to understand
2. Run it and see the result — "Oh, so that's what happens"
3. Forget it right away — that's fine. Forgetting is natural
4. Do it again later — "Hey, I think I've seen this before"
5. Find it fun through repetition — "Wait, could I make something like that?"
6. Look it up when you're curious — "Ah~ so that's what it was!"

Don't try to figure out the principles from the start. We're not retracing the entire history of computers. We're touching these fascinating things right in front of us, naturally absorbing them as we go.

And this isn't just motivational talk. There's scientific evidence.

Part 2. Your Brain Will Handle It — Science Guarantees It

From here, let me talk about my field. As a biotech researcher, let me explain why our brains are built for "just repeat and it works."

Hebb's Rule: "Neurons That Fire Together Wire Together"

In 1949, neuropsychologist Donald Hebb discovered this principle.

The brain has roughly 86 billion neurons (nerve cells), and they communicate through junctions called synapses. Hebb's rule states:

"Neurons that fire together, wire together."

When you see the word print → type on the keyboard → and see the result on screen, neurons in your visual cortex, motor cortex, and reward circuits fire simultaneously. The synapses between these neurons physically strengthen with each repetition. AMPA receptors increase on the postsynaptic membrane, and Long-Term Potentiation (LTP) occurs.

In simple terms, repeat, and your brain builds the connections automatically. You don't need to try to understand. Your brain does it for you.

neurons = ["Visual (seeing 'print')", "Motor (typing on keyboard)", "Reward (output appears!)"]

for neuron in neurons:
    print(f"🧠 {neuron} → Firing!")

print("\n→ Synapse strengthened! Next time it'll be faster.")

assert len(neurons) == 3

Procedural Memory: Your Body Remembers

There are two types of memory.

Declarative Memory is memorizing facts like "in Python, a variable is a container that stores values." The hippocampus handles this, and you forget it easily.

Procedural Memory is formed through repetitive actions like riding a bike, pipetting, and — coding. The basal ganglia and cerebellum handle this, and once formed, it's hard to forget.

Memorizing coding syntax from a textbook is declarative memory. You'll forget it quickly. But when you type code yourself, run it, encounter errors, and fix them over and over — that becomes procedural memory. Like riding a bike, like pipetting, your hands remember.

That's why we don't teach theory first. We do it first.

memory_types = {
    "Declarative Memory": {"example": "'for' is a loop statement", "brain_region": "Hippocampus", "duration": "Easily forgotten"},
    "Procedural Memory": {"example": "Typing and running code yourself", "brain_region": "Basal ganglia + Cerebellum", "duration": "Long-lasting"},
}

for name, info in memory_types.items():
    print(f"\n📌 {name}")
    print(f"   Example: {info['example']}")
    print(f"   Brain region: {info['brain_region']}")
    print(f"   Trait: {info['duration']}")

assert "Hippocampus" in memory_types["Declarative Memory"]["brain_region"]
assert "Basal ganglia" in memory_types["Procedural Memory"]["brain_region"]

Myelination: Slow at First, Then Suddenly Fast

Neurons have long projections called axons. Electrical signals travel along these axons. At first, axons are like bare wires, so signals move slowly.

But when the same pathway is used repeatedly, oligodendrocytes start wrapping a substance called myelin around the axon. This is myelination.

Once myelination progresses, signal transmission speed increases by up to 100 times — thanks to saltatory conduction.

Here's what this means:

• First time coding: thinking for 3 minutes to type print → normal
• Tenth time: "Oh right, print... that shows output" → myelin is forming
• Thirtieth time: your hands type print() before you think → myelination complete

You know that experience where "one day it suddenly clicks"? That's not just a feeling. Myelin has built up enough that signals got faster. It's a physical change.

stages = [
    ("Trial 1", 0.5, "Slow conduction"),
    ("Trial 10", 5.0, "Myelin forming"),
    ("Trial 30", 50.0, "Saltatory conduction!"),
]

print("🧬 Myelination Simulation\n")
for trial, speed, status in stages:
    bar = "█" * int(speed)
    print(f"  {trial:>10s} | {bar:<50s} | {speed:>5.1f} m/s — {status}")

assert stages[2][1] == 50.0

So, Science Says

• Hebb's Rule: Repeat, and your brain builds the connections
• Procedural Memory: You have to do it yourself for your body to remember
• Myelination: Slow at first, but repetition physically makes you faster

All three tell us one thing:

You don't need to understand. Just repeat. Your brain will handle it.

This isn't motivational talk. It's AMPA receptor density increasing at synapses, procedural circuits strengthening in the basal ganglia, and myelin wrapping around axons — measurable physical changes.

Alright, Let's Begin

Here's what we're doing:

• We are not studying the history of computer science from scratch
• We are not memorizing programming language syntax
• We are most certainly not creating a new programming language

We're learning to use existing tools for our research. Computer scientists built the foundations. We leverage them. Just like you can run a perfect PCR without knowing the circuit design of the thermal cycler.

Even if you don't understand right away, just follow along. Even if you forget immediately after seeing it, that's fine. Just try the things here as they are, and think "Hmm... I guess that's how it works" and move on.

After a while, you'll think "Wait, couldn't I make something like this too?" Come back and look it up then. "Ah~ so that's what it was." And you progress, little by little.

This is that kind of space. A place where you don't need to understand coding — or even the latest AI — from the beginning. Just like how we first learned to speak, a space where you naturally absorb things.

print("=" * 40)
print("  🧪 Welcome to DevBench")
print("  Don't understand. Just start.")
print("=" * 40)

started = True
assert started == True

In the next lesson, we'll open a terminal. You'll learn that the black screen isn't scary at all.