C++ was the first language that made me responsible for the machine. There was no framework quietly handling memory, no browser hiding the details. If I got the lifetime of an object wrong, the program told me in the least helpful way possible.
The problem
In 2012, I moved from web technologies and visual programming into C++ because I wanted to understand desktop applications. I was learning alone, working through small programs and later using Qt Creator. There was no product plan. The goal was to make things work and understand why they worked.
The first obstacle was ownership. A pointer could outlive the object it referred to. A dialog could block the wrong thread. A build could fail because a header was included in the wrong order. These were concrete failures I had to reproduce, read, and fix, not abstract language features.
The build
I kept building small exercises and then turning them into slightly larger applications, one window and one form at a time. Each one added a new constraint: a window that had to update state, a form that had to validate input, a class that had to keep its data consistent. I learned to separate the UI from the logic so I could test a function without opening a window or clicking through a form. I learned to read compiler errors instead of guessing at the first fix.
The projects were deliberate practice, not polished products. That distinction helped. I was trying to build the mental model that later systems work would require, not convince anyone that a small desktop app was a startup.
Qt also introduced me to event-driven programming: signals, slots, and a UI that stayed responsive while work happened elsewhere. That was a different mental model from the straight-line exercises I had written before. I made mistakes with object ownership and learned to use the framework's parent-child model deliberately rather than hoping memory would sort itself out. The small apps were where those ideas became habits, and where I learned that a clean build is not the same as a correct program.
The result
I built a series of small C++ desktop applications with Qt Creator and established the foundation for later desktop, robotics, and AI-related work. The visible output was modest. The durable output was confidence with a language that does not forgive hand-waving.
What I took from it
Looking back, this was the start of my longer C++ phase. Self-study gave me the confidence to take on bigger systems later, and it taught me that understanding a language means understanding its failure modes as well as its syntax. That lesson has remained useful in every language I have used since.