What Writing Code Really Means, Most Developers Get It Wrong
Most developers write code for years without understanding what computing actually is.
Understanding what writing code really means starts at the lowest level. At its core, computing follows one pattern: Input → Transformation → Output. Every system ever built, from a basic calculator to a distributed backend, runs on that loop. The real question, however, is how the machine performs that transformation.
Inside a computer, there are no variables, no functions, no objects. There is only binary data, zeros and ones. Every line of code, whether it is an if-statement, a loop, or an API call, gets compiled or interpreted into machine instructions. Those instructions are simply numbers.
The CPU carries out the actual work. It runs a continuous cycle: Fetch, Decode, Execute. It gets the next instruction from memory, understands what it means, and then performs the operation, whether that is math, logic, or memory access. So when a developer writes const sum = a + b, the CPU does not see JavaScript. Instead, it loads two values into registers, adds them, and stores the result. That is what writing code really means at the hardware level.
Meanwhile, the GPU operates differently. Unlike the CPU, which handles sequential tasks with complex logic, the GPU runs thousands of smaller cores simultaneously. That parallel power is why GPUs dominate graphics rendering, machine learning, and simulations. The same instruction fires across massive datasets all at once.
Every program, therefore, transforms data. An API transforms a request into a response. A database transforms queries into results. A frontend transforms state into UI. Beneath all of it, data moves through memory, gets processed, and is written back.
Crucially, most performance problems are not about computation. They are about data movement. CPUs are fast, but memory access is slow. A system’s efficiency depends on how often it touches memory, how data is structured, and how much it gets shuffled around. Developers who ignore this end up over-fetching data, building inefficient APIs, and guessing at performance rather than reasoning about it.
Dagana also points out what most developers miss about scale. Scalable systems are large-scale data transformation pipelines. A backend service processes requests. A queue system moves data between services. A database stores and retrieves structured data. At scale, the job is not handling requests, it is managing how data flows, transforms, and persists across machines.
The mindset shift Dagana urges is direct: stop asking “how do I build this feature?” and start asking “what is the data, and how does it move?” That question separates developers who write features from engineers who design systems.
Computing is not magic. It is the structured transformation of data through hardware constraints. Once developers internalize what writing code really means, they stop working blind and start building with intention.
