What You're Really Doing When You Write Code

Jason Dagana — Mon, 20 Apr 2026 18:28:04 +0000

Most developers spend years writing code...
without ever understanding what computing actually is.

That's a problem.

Because until you understand how a machine processes information, you're not really designing systems—you're just arranging syntax.

Computing, Stripped to Its Core

At its lowest level, computing is simple:

Input → Transformation → Output

That's it.

Every system you've ever used—whether it's a calculator, a backend API, or a distributed system—follows this pattern.

But the real question is:

How does the machine actually perform that transformation?

Everything Is Data (Even Your Code)

Inside a computer, there are no "variables", no "functions", no "objects".

There is only:

binary data (0s and 1s)

Your code:

if statements
loops
API calls

All get compiled or interpreted into machine instructions.

Those instructions are just numbers.

The CPU: The Real Executor

The CPU is the component that actually does the work.

It follows a simple loop:

Fetch → Decode → Execute

1. Fetch

Get the next instruction from memory

2. Decode

Understand what that instruction means

3. Execute

Perform the operation (math, logic, memory access)

Example

When you write:

const sum = a + b;

The CPU doesn't see JavaScript.

It sees something closer to:

Load a into a register
Load b into a register
Add them together
Store the result

That's computing.

The GPU: Specialized Parallelism

While the CPU is general-purpose, the GPU is built for:

running thousands of smaller cores that execute the same instruction across different data points simultaneously

That's why GPUs dominate:

Graphics rendering
Machine learning
Simulations

Where a CPU has a few powerful cores optimized for:

sequential tasks with complex logic and branching

A GPU has thousands of simpler cores optimized for:

massive parallelism — applying the same operation across huge datasets at once

What "Transformation" Actually Means

Every program you write transforms data.

Examples:

API → transforms request into response
Database → transforms queries into results
Frontend → transforms state into UI

Underneath all of it:

Data moves through memory, gets processed by the CPU/GPU, and is written back.

Memory Is the Real Battlefield

Most performance issues aren't about computation—they're about data movement.

Why?

Because:

CPUs are fast
Memory access is slow

So your system's efficiency depends on:

How often you access memory
How data is structured
How much you move it around

From This to Scalable Systems

Here's what most developers miss:

Scalable systems are just large-scale data transformation pipelines.

Think about it:

A backend service → processes requests
A queue system → moves data between services
A database → stores and retrieves structured data

At scale, you're not "handling requests".

You're:

managing how data flows, transforms, and persists across machines

Why This Knowledge Matters

Without understanding computing:

You over-fetch data
You design inefficient APIs
You ignore memory costs
You misuse concurrency
You guess performance instead of reasoning about it

With it:

You design systems that scale naturally
You understand bottlenecks
You make intentional trade-offs

The Shift

Most developers think:

"How do I build this feature?"

Better developers think:

"What is the data, and how does it move?"

That's the difference.

Final Thought

Computing isn't magic.
It's not abstract.
It's not high-level.

It's:

structured transformation of data through hardware constraints

Once you understand that:

You stop writing code blindly...
and start engineering systems deliberately.

DEV Community: Jason Dagana

What You're Really Doing When You Write Code