Programming9/27/2026

How I Learn Programming: Build, Break, Fix, Repeat

I did not come from a traditional software-development background, so I learn programming in the way that works best for me: building real projects, facing real problems, and learning technologies when they are actually needed.

I did not begin my career as a programmer or software developer. My background is engineering, so when I started learning programming I needed to find an approach that matched the way I understand things.

I tried learning syntax sequentially: variables, loops, functions, classes, databases, frameworks, and so on. These concepts are important, but without practical context I frequently wondered where they would actually be used.

I eventually realized that I learn more effectively when I have a problem I genuinely want to solve.

Instead of learning all of JavaScript first, I preferred building a website. When I needed buttons, I learned about events. When I needed data, I learned how frontends communicate with backends.

Authentication became relevant when I needed login functionality. Role-based access control became relevant when applications required different types of users.

Databases became necessary when information needed to survive application restarts.

As database requirements became more complex, I encountered table relationships, primary keys, foreign keys, migrations, backups, and restores.

This approach gives every concept a practical reason to exist.

Piping Stuff by AR is one example. The project originated from a field I already understand: piping engineering.

I wanted to make engineering data easier to access through software. That objective generated software questions: how should dimensional data be stored? How should NPS and schedules be selected? How should components be visualized? How should 2D and 3D views work? How should authentication be implemented?

One engineering idea opened the door to many programming topics.

i-Kata Tours & Travel introduced different problems: tour packages, destinations, bookings, customers, administration, roles, image uploads, PDF brochures, multiple currencies, bilingual content, backups, and restores.

It taught me that applications are much more than attractive pages. Behind the interface are data, business logic, access control, security, error handling, databases, and application lifecycle concerns.

ARMedias introduced storage and media management. AR Python Manager introduced portable environments and dependency management. AR CyberLab introduced learning platforms and isolated environments.

ARCLAW introduced AI, messaging integrations, agents, memory, tool execution, scheduling, and access control.

Every project presents different problems, and every problem requires learning something new.

The most valuable lessons usually do not occur when everything works.

They happen when something fails.

Database errors. Missing dependencies. Services that refuse to start. Ports already in use. Permission errors. Incorrect environment variables. Unexpected API responses. Empty frontends. Crashed backends.

Errors initially felt like obstacles. Over time, I began treating them as information.

An error usually indicates that one of my assumptions is incorrect. The challenge is identifying which assumption.

I learned to read logs before changing code, reproduce problems, and inspect components individually. Is the database running? Is the backend listening? Is the request reaching the server? Is the configuration correct?

This troubleshooting process feels surprisingly similar to engineering.

There is a system with inputs, processes, outputs, and expected conditions. When the output differs from expectations, we identify which part of the system is not behaving according to design.

Perhaps that is one reason programming feels natural to me despite my engineering background.

I also adopted Git for managing changes. After experiencing situations where a new modification broke something that previously worked, the value of version control became increasingly clear.

The same is true for backups.

Backups rarely feel important until the moment they are actually needed.

As my projects grew, I became interested not only in code but also in what happens after software is built.

How should it be deployed? How should updates work without losing data? What happens if an update fails? How can a previous version be restored? How should persistent data be protected?

These questions moved me toward Linux, servers, containers, deployment automation, and infrastructure.

More recently, AI-assisted development has become part of my workflow.

AI can explain errors, provide code examples, assist research, and accelerate prototypes. But I have also learned that AI-generated output still needs verification.

If I do not understand what the code is intended to accomplish, troubleshooting becomes difficult when something fails.

I therefore try to use AI as a tool for accelerating learning and development rather than replacing understanding.

I am still far from knowing everything about programming. In fact, learning more usually reveals even more areas I have yet to understand.

But I am no longer particularly worried when I encounter unfamiliar technology.

I understand the learning pattern.

Decide what to build. Break it into smaller problems. Identify the technologies required. Build the first version. Run it. Find the errors. Read the logs. Fix them. Document what was learned. Then repeat.

Build. Break. Fix. Learn. Repeat.

For me, that is one of the most effective ways to learn programming.

ProgrammingWeb DevelopmentPythonNode.jsLinuxLearning