Coding Is Hard

In my experience programming is less having it all in your head and more where and how to look things up. Because pretty much no one has it all in their head, and the ones that do are hyper-specialized workaholics and would be just as slow as anyone outside of that specialty.

It's possible the things you're trying to do are just too difficult, but you are incorrectly assuming that they are easy and that everyone can do them. (This is especially common in game development - someone wants to create a 3D open-world MMO, not realizing that such projects typically take years to develop, even for teams of dozens or hundreds of engineers and artists.)

It's possible there's some fundamentals of programming that you never properly mastered. People sometimes go through multiple programming courses, but still have a shaky understanding of how basic control flow works, then wonder why they are struggling in their higher level courses.

It's possible you have some other weakness without realizing it, like (for example) trying to code from memory rather than regularly referencing the documentation (some people have this weird notion that you're supposed to memorize what every function does, when that actually couldn't be further from the truth).

Without working with you directly, it's hard for me to say what the exact problem is. You should have someone sit down with you and help you identify what's causing you to struggle.

Sigh. Refactoring is hard. Finding the "right" structure (whatever that means) is hard. Changing the existing code from one structure to another is hard. There is a huge amount of uncertainty and so many ways for it to go wrong. There are an infinite number of ways to change things and you don't really know which change is "best" until you try a lot of them and then look at what you made. Now that I'm 25 years into this, I have a sense of where the dead ends are and how to avoid them, but after 10 years a lot of people don't. And I still go down dead ends sometimes. The key is realizing when you're on a dead end as quickly as possible, then stopping and doubling back. Cut that sunk cost loose.

If you go into something with the expectation that it will be easy, you won't have the right mindset to deal with difficulties. When you hit difficulties, you'll strain against them instead of calmly taking a step back and reassessing the situation. The problem isn't being dumb. It's the act of straining itself, which makes you dumb.

Most difficulties are caused by not fully understanding the problem being solved, and the "easy" solution turns out to have overlooked some of the essential complexity that needed to be solved, which leads to kludges piled on kludges. Understand first. Then solve.

It's important to have a problem solving process. Look at times that you did find a solution. How did you approach it? What was helpful? What wasn't? Refine your process over time, keeping what works and discarding what doesn't. Then trust your process and relax. It's just a website.

I had done a lot of self-taught stuff as a teenager, but honestly the essence of programming eluded me until 12-18 months into my CS undergrad. A lot of it was just the reps, but the structure of having a dedicated professor and assignments gave me a focus that really helped. I also think it was good to work primarily with backend languages like C, C++, Java and Scheme without the distraction of web and GUI elements that have a world of complexity (often incidental) that distracts from understanding the basics of data structures and algorithms.

The next big leap was working on a team in a professional setting. In my case it wasn't even with other programmers, I worked primarily with non-technical stakeholders as the sole web designer and programmer on a design team that primarily did print design (yeah this was a while ago). Even though I didn't have technical mentors in that first job, just the accountability of having to deliver on some projects that multiple people were contributing to taught me a ton about how to do what was necessary to consistently ship. This is the number one thing to improving: you've got to ship and keep shipping. If you get stuck, cut scope and ship something simpler. Just never stop shipping.

Finally, a word on motivation. I'm not here to judge anyone's motivations: do whatever works for you. That said, I feel the best motivation for getting good at programming is curiosity about how things work. If you're not innately curious about technical things, the steady stream of compiler errors and bugs will eventually grind you down. Perhaps this is what the title is referring to. Personally I don't think of programming as hard, but that's because the high I get from debugging a thorny issue outweighs the pain of understanding the root cause. Multiple times the author discloses an expectation that something should be easy, and then getting frustrated when it's not. Whatever your motivation, you've got to have some tenacity and grit to put in the work to power through—that's how it will become easier over time, not due to innate intelligence or time spent on tutorials/videos/reading materials.