Perhaps you're wondering what the overall process for learning to code is like. This post gives an overview.
Learning to code can be split into different stages.
In the beginner stage, the focus is on learning the fundamental building blocks of programming.
In the intermediate stage, the focus is on becoming fluid at combining the building blocks into increasingly complex programs.
In the advanced stage, the focus is on managing complexity and having a breadth of knowledge.
All programs are built up from simple building blocks. These are things like variables, strings, numbers, and functions.
In the beginner stage, it is necessary to conceptually understand each of these building blocks: the what of programming.
It is also necessary to become familiar with the syntax of the building blocks: the how of programming. The beginner must learn precisely which symbols to type in which order to make the computer understand them.
There aren't that many building blocks; perhaps there's a dozen. To get past the beginner stage, it is necessary to understand each building block and know the syntax well enough to be able to use it.
It is crucial to have enough practice actually writing code with each building block that it can be naturally used in different contexts.
Before this stage, the programmer knows nothing. After this stage, they are familiar with the terminology and can use the different building blocks.
In the intermediate stage, the programmer can use all the building blocks. However they do not yet have much experience combining these building blocks to create useful, realistically-sized programs.
There is not much conceptual learning in the intermediate stage. Instead, the focus is on craftmanship and gathering experience. To get beyond this stage, the best approach is to build real projects.
Before this stage, the programmer is only able to solve toy problems. After this stage, the programmer is able to solve real problems and develop small projects.
In the advanced stage of programming, the focus is on learning techniques that make developing even huge, complex programs manageable.
It is difficult to make a comprehensive list, since there are so many factors that all play a role. But we will list some prerequisites.
Having a breadth of knowledge becomes necessary. The developed programs should scale well, which requires a deep understanding of algorithmics. They should be reliable, which requires good software architecture and could involve using a test-based development approach. They should be secure, which requires understanding common security pitfalls.
The advanced programmer should also have mastered various programming tools, such as version control systems and their preferred editor.
At this stage, design and architecture start to matter significantly, to make large code bases maintainable and relatively bug-free.