DEV Community: Utkuhan Akar

From Voltage to Logic: What I Learned While Digging into the CPU's Heart

Utkuhan Akar — Sun, 12 Apr 2026 21:32:59 +0000

It’s April 13, 2026. While the world outside is talking about the latest high-level abstractions and automated systems, I’ve spent my last few nights in the "basement" of computing. Preparing for my upcoming exams at Samsun University has led me down a rabbit hole I didn't expect: The Assembly Language and the raw, electric reality of 0s and 1s.

As a software engineering student, we often start our journey with languages like Python or C. We treat memory as an infinite playground. But when you strip away the layers, you realize that computers don't actually "calculate" numbers—they manipulate electricity in a highly choreographed dance.

It’s Not Just 0s and 1s: The Physics of Logic We always hear the cliché: "Computers only understand 0 and 1." But here is the first "Aha!" moment I had during my study sessions: A computer has no idea what a "1" is. It only knows Voltage Levels.

Inside a CPU, a "0" is typically a low voltage (0V to 0.5V), and a "1" is a high voltage (near 1.1V or 1.8V in modern architectures). The magic happens at the Logic Gates. Using billions of transistors as tiny, microscopic switches, we force electricity to perform logical operations like AND, OR, and XOR.

When you write if (a > b), you aren't just asking a question; you are routing electrons through a specific physical path of transistors that will output a high voltage (True) or low voltage (False) based on the input.

The Language of the Metal: Assembly and Registers Moving from C# to Assembly is like jumping out of a comfortable, self-driving car and trying to run at 100 mph on your own bare feet.

In Assembly, the concept of a "variable" disappears. Instead, you have Registers—the CPU's internal, lightning-fast scratchpads. During my exam prep, I realized how critical these are. If the CPU is a chef, the RAM is a grocery store miles away, and the Registers are the chef's hands.

MOV EAX, 100: You are physically moving a bit pattern into the EAX register.

ADD EAX, EBX: You are signaling the ALU (Arithmetic Logic Unit) to combine the voltages of two registers and store the result.

Everything—your mouse movements, your 4K video renders, your game physics—is just a sequence of these tiny "MOV" and "ADD" instructions happening billions of times per second.

The Hidden Architecture: The Stack and the Instruction Pointer One of the most challenging parts of my studies was understanding the Stack. When a function calls another function, how does the computer remember where to go back?

I learned about the Stack Pointer (ESP) and the Instruction Pointer (EIP). The EIP is like a bookmark; it points to the next line of code to be executed. When a function is called, the current EIP is "pushed" onto the Stack. When the function finishes, it is "popped" back. This is why "Stack Overflow" isn't just a website; it's a physical reality where your CPU runs out of room to remember where it was.

Interrupts: The CPU's "Hey, Look at Me!" I also spent time studying Interrupts. How does the CPU know I clicked my mouse while it's busy calculating a complex algorithm? It doesn't "check" the mouse constantly (which would be inefficient polling). Instead, the hardware sends an Interrupt Signal. The CPU literally stops what it's doing, saves its registers, handles the click, and then resumes. It’s a level of multitasking that we take for granted but is breathtakingly complex at the hardware level.

Conclusion: Why Does This Matter in 2026?
You might ask: "Utkuhan, why are you studying 50-year-old concepts in 2026?"

Because abstraction is a gift, but understanding is power. Even in an era where we can generate entire applications with a few prompts, the machine at its core hasn't changed its fundamental logic.

Knowing how the registers move, how the cache levels (L1, L2, L3) affect performance, and how the stack grows makes you a better engineer. It allows you to write code that isn't just "functional" but is sympathetic to the hardware.

I’m heading back to my Assembly notes now—the exams at Samsun University won't wait. But next time you run a single line of code, take a second to appreciate the billions of transistors flipping in perfect harmony just to satisfy your command.

I Knew About Gravity. But I Hadn't Thought About the Equation Behind It This Way

Utkuhan Akar — Sun, 05 Apr 2026 08:45:12 +0000

I didn't "learn" about gravity recently. Like everyone else, I've known the basic idea for years. Objects fall, masses attract each other, and names like Newton or Einstein are so familiar that the subject feels almost "closed" in my mind. But lately, I've started looking at gravity not as something I already understood, but probably as something I've oversimplified for a long time, especially when I try to relate the intuitive idea to the actual equations behind it.

The most basic expression of gravity is Newton's law:

F = G * (m₁m₂ / r²)

I've seen this formula many times before, used it in problems, accepted it as a rule, and moved on. But I realized I never asked myself what this equation actually tells me about reality. Not how to calculate it, but why it has exactly this structure. Why does the force decrease with the square of the distance? Why isn't it linear? Why isn't it something else entirely? At first glance, it seems arbitrary, something discovered and then accepted, but as I began to read further, it became clear that this "1/r²" behavior is not at all random, but rather deeply connected to the geometry of space.

If an effect propagates in three-dimensional space, it doesn't just travel in a line, it spreads into an area, and this area grows with the square of the distance from the source. Therefore, everything that "propagates" is diluted on this growing surface, which naturally leads to a decrease proportional to 1/r². This realization changed my perspective somewhat, because now the equation is not just a law of physics, but also a reflection of spatial structure. It's not just about gravity, but about how things behave in a three-dimensional world.

Then, moving on to Einstein's formulation makes things even less intuitive. Instead of thinking in terms of forces acting between objects, you encounter an equation like this:

G_{μν} = (8πG / c⁴) T_{μν}

I don't claim to understand this equation mathematically, nor do I claim to be able to derive anything from it. However, I have tried to understand what it is trying to describe conceptually. As I understand it, the left side represents the geometry of spacetime, while the right side represents the distribution of energy and matter. Simply put, it suggests that matter and energy determine how spacetime curves, and that curved spacetime determines how objects move.

This is where things stop looking familiar. In Newton's picture, you can imagine a force pulling objects together, something acting between them. But here, that idea disappears. Gravity is no longer something that "acts" on objects in the traditional sense. Instead, it becomes a description of how the structure of spacetime is shaped, and motion becomes a consequence of that structure rather than the result of an applied force.

What makes internalizing this even more difficult is the idea of free fall. From this perspective, an object in free fall isn't actually subjected to a force within its own frame. It simply follows a path defined within a curved spacetime, which can be thought of as the closest thing to a straight line, called a geodesic. So the object isn't being pulled in the way we usually imagine; it's simply moving along the natural path defined by the geometry it's in.

This creates a contradiction with intuition, because almost all of our everyday understanding of motion relies on forces: pushing, pulling, resisting. We expect something to directly "cause" motion in some way. But within this framework, motion can occur without such interaction, which makes it difficult to visualize and accept, even if the mathematical explanation is consistent.

I'm not writing this as someone who has perfectly mastered the mathematics behind these ideas. Much of what I've understood comes from reading, trying to interpret explanations, and slowly piecing the pieces together. And what I've realized is that the difficulty lies not just in learning new formulas, but in taking familiar formulas seriously and questioning what they imply about reality.

What changed for me wasn't learning a new equation, but stopping seeing the equations I already knew as just problem-solving tools. Instead, I started seeing them as condensed descriptions of how the world might actually work. And when you do that, even something as "fundamental" as gravity starts to seem far less obvious than before.

I think that's where physics gets interesting again. Not when you encounter something completely new, but when something you thought was simple turns out to be deeper than you imagined, and you realize that understanding it correctly requires more than just knowing the formula.

In the software world, problems and solutions will certainly present themselves in a similar way, but you determine which area you will grow in and where you will go.

How I Actually Use AI While Coding

Utkuhan Akar — Tue, 31 Mar 2026 19:25:37 +0000

Lately I’ve been using AI a lot while coding.

But not in the way most people think.

I’m not opening AI and saying “build this for me”.

Most of the time it looks more like this:

Real Scenario 1 — Getting Stuck

I’m writing something simple, like a layout or a component.

At some point, things stop making sense.

Instead of dumping everything to AI, I usually write something like:

“I’m trying to do X, but this part feels wrong. Can you point out what I’m missing?”

Not asking for code.

Just asking where I’m thinking wrong.

Most of the time, that’s enough.

Real Scenario 2 — Something Works, But Feels Wrong

Sometimes the code works.

But I know it’s not clean.

That’s when I do this:

“This works, but I feel like it’s messy. Where is the problem?”

And AI usually points out things like:

repetition
bad structure
unnecessary complexity

That’s useful.

Because I already solved the problem — now I’m improving it.

Real Scenario 3 — I Don’t Understand My Own Code

This happens more than I’d like to admit.

I write something, it works…
but if you ask me to explain it, I’d struggle.

So I ask:

“Explain this like I wrote it but didn’t fully understand it.”

That’s where AI becomes actually valuable.

What I Don’t Do

I don’t do this anymore:

“Build me a full app”
“Write everything from scratch”
Blind copy-paste

Because I tried that.

It works short term.

But after a while, you realize:

You’re not improving — you’re just producing.

The Only Rule I Follow

Before I ask AI, I ask myself:

“Did I actually try to solve this?”

If the answer is no, I don’t open AI yet.

Small Change, Big Difference

The biggest change for me was this:

Instead of asking AI to do things for me
I started using it to question my thinking

That’s it.

Final Thought

AI is powerful.

But if you use it the wrong way, it just makes you faster — not better.

Right now I’m trying to use it in a way that:

makes me think more
not less

Still figuring it out.

Stop Coding More — Start Improving How You Code

Utkuhan Akar — Tue, 31 Mar 2026 19:10:49 +0000

I Stopped Just Coding — I Started Building a System That Improves Me

Most developers write code.

But very few actually analyze how they write code.

I realized something simple:

Writing more code doesn’t automatically make you better.

So I started building a system — not just projects.

The Problem

While learning and building projects, I noticed patterns:

I repeat the same mistakes
I don’t track how I improve
I use AI, but I don’t improve how I use AI
I discover good repositories too late (or never)

This means:
I’m working… but not evolving efficiently.

The Idea: A Developer Intelligence System

Instead of just coding, I’m designing a system that:

Tracks how I write code
Detects patterns in my mistakes
Suggests improvements in real-time
Recommends high-quality GitHub repositories (even low-star ones)
Helps me improve my prompts when using AI

How It Works (Concept)

The system has multiple layers:

1. Code Awareness

While I write code, the system analyzes:

structure
repetition
complexity

Example:

“You repeated this logic 3 times — extract a function.”

2. Error Intelligence

Instead of just fixing errors, it tracks them:

What mistakes do I repeat?
What concepts am I missing?

Example:

“You’ve made similar CSS mistakes 5 times — review box model.”

3. Smart Repository Discovery

GitHub search is limited.

This system focuses on:

code quality
learning value
structure

Not just stars.

4. Prompt Evolution

Using AI is not enough.

Improving how you ask is everything.

The system:

saves my prompts
compares outputs
suggests better versions

5. Content Generation

Everything I learn turns into:

notes
posts
technical articles

So learning → becomes output.

Why This Matters

AI is changing development.

But there are two types of developers emerging:

People who use AI
People who learn how to use AI effectively

The difference is massive.

My Goal

Not just to write better code.

But to:

think better
learn faster
build systems that improve me over time

Final Thought

Instead of asking:

“How do I build this project?”

I started asking:

“How do I build a system that makes me better every day?”

That question changed everything.

If you're building something similar or thinking about it, I’d like to hear your approach.

How I Built My Portfolio Website as a Beginner Developer

Utkuhan Akar — Sat, 28 Mar 2026 19:22:03 +0000

How I Built My Portfolio Website as a Beginner Developer

Hi, I am Utkuhan Akar, a software developer focused on AI and web technologies.

Recently, I built my own portfolio website to showcase my projects and track my progress.

Why I Built It

I wanted a place where I can:

Share my projects
Show my skills
Build an online presence

Technologies I Used

HTML
CSS
JavaScript
GitHub Pages (for deployment)

What I Learned

Building this project helped me understand:

How to structure a real project
Basic frontend development
Hosting a website using GitHub

My Portfolio

You can check it here:
👉 https://utkuhanakar.github.io/Portfolio/

What’s Next

I will improve this website, add new features, and later move it to a custom domain.

Thanks for reading 🚀