Skill builders to increase your native coding fluency.
I'm stealing...err...borrowing profusely from human language learning and current brain science to help us all code better and learn more.
When you start learning a foreign language, human or computer, you sound like an idiot. Benny Lewis, a famous polyglot, describes this as talking like "Tarzan". Very basic words and really bad grammar.
When you're new to a language, struggling through that initial level can be very discouraging. However, if you can achieve a small success, your brain rewards you with dopamine. You feel good, and your learning progresses faster than if you are discouraged. Repeated success builds learning velocity.
Fluency, in this context, is the ability to communicate at a basic level without having to struggle through each and every word choice. You still sound like Tarzan, but a more relaxed Tarzan. In programming, you can do basic things like variable assignment, loops, if tests, etc, without having to think too much about it.
That "think too much" is key. The human conscious mind can only think about one thing at a time. One. Single. That's it. That means that if you have to think about how to properly define a map so the compiler doesn't yell at you, your brain has to context switch away from thinking about the problem space and it must focus on the language constructs.
That's the goal here; to help you practice with the language as a tool so that you can focus on the problems you want to solve, and not the tools you're using to solve them. If you can push your coding skills into your subconscious then you can work much faster.
You would normally gain this level of skill over the course of a few months. Lots of people have, there's no secret to what you need to learn. The real question is, can you learn it faster? What if you could move some of the key skills into the sub-conscious in a week?
There are three directories: "Common", "Compiled", and "Interpreted". Start with the "Foundations.md" project relevant to your language type, and then later move to the other projects in your language type, and "Common".
Start with Foundations. Create your file in a temp directory, and follow the instructions. Do each task without referencing Stack, IRC, or anything else. Just your mind and your skills. Do the entire exercise before correcting anything. Keep trying to run it; keep going until it works. If you get all the way through and still can't make it work, then look things up. But not until you give it your best effort.
If you're really new to your language there will be a lot of room for improvement. That's okay. Put on your "Big Coder" bloomers, accept the challenge, and study what you had to look up. Those challenges give you critical feedback, you now know exactly what you need to practice more.
At the end of the session, delete the file. Let the learning sink into your brain, and tomorrow start fresh. One day, probably very soon, you'll get it all right on the first pass. Congratulate yourself, treat yourself to an extra coffee, or whatever, and spend the rest of the day basking in your success.
The next day, start the next project.
We're using some cool things; Spaced Repetition, Sensory Engagement, and Flow. By doing one project a day we allow the brain to process what it has learned, and we do not over-stress the learning to force success. Trying to force it only makes failure stronger and more frequent.
With actual coding, we're engaging the body much more than just reading a book. I love books, but until I type things out and have to deal with the mistakes, I don't really understand. When I do the typing, and work through the bugs I engage at a much more active level.
That leads us to Flow. As long as the projects give you a little challenge, they push you to perform at a slightly higher level. Doing that successfully, and doing it over the course of a few days, not only builds your skill but it builds your confidence and enjoyment of the process. That's a serious win!
This isn't an academic discourse trying to teach you the nuance of, well, anything. This is a pragmatic translation of the Pareto principle to learning to code. The Pareto principle is that "80 percent of the success come from 20 percent of the work" thing managers like to talk about. The good news is that it's true; you can probably do 80% of the things that need doing with about 20% of the language. By focusing on that 20%, you learn faster and can produce good work faster.
This assumes you have completed some basic learning in your language of choice. For example:
A Tour of Go https://tour.golang.org/list
Exercism https://exercism.org/tracks/go
Learning Go https://www.amazon.com/dp/1492077216
Introducing Go https://www.amazon.com/dp/1491941952
Programming with Google Go Specialization
https://www.coursera.org/specializations/google-golang
Learn to Program http://www.alan-g.me.uk/l2p2/
A Byte of Python https://python.swaroopch.com/
Exercism https://exercism.org/tracks/python
Practical Programming: An Introduction to Computer Science Using Python 3
https://www.amazon.com/dp/1937785459
Python for Everybody Specialization
https://www.coursera.org/specializations/python
Learn C https://www.learn-c.org/
Exercism https://exercism.org/tracks/c
C Tutorial https://www.cprogramming.com/tutorial/c-tutorial.html
Learn C the Hard Way
https://www.amazon.com/dp/0321884922
Introductory C Programming Specialization
https://www.coursera.org/specializations/c-programming