500 Hours Learning Programming Fundamentals Taught In 10–30 Hours By Other Sites
(Skip to the bottom for a list of all the concepts I’ve covered)
This article isn’t a complete knock on those websites that do spend less time covering programming fundamentals. These sites also expect that you will spend many hours honing these fundamentals, mostly through the creation of projects. There are also some benefits to their constraints. It requires being able to explain concepts in as simple a manner as possible. Exercises, projects and concepts defined within this constraint are very helpful. Whenever I learn about a new concept I will go to these sites first because they have simplified very complex topics. To learn programming requires accepting yourself as beginner when covering new topics.
But you’ve probably noticed there is a gap among the ocean of content at the beginner level and what’s needed to get to a professional level. I used to think it was because there was so much to learn. While there is, there’s a big difference to the depth into which most concepts are covered and how they are taught. Many sites expect you to be able to fill in the gaps yourself once topics are covered mostly by creating projects and they have you learn a framework that covers these gaps. Filling in the gaps is hard because learning to programming is a paradigm that many people have no experience in. Using frameworks too early is sort of like duck taping gaps in your knowledge.
After learning programming for a while, I feel I can now articulate why I wasn’t able to use these basic resources for more advanced learning. One reason was that I was not an effective student, the second one was that I could never agree with the learning path laid out by these courses.
There’s learning processes common across learning new skills. For example, if you started learning a sport, you learn the rules and strategy (conceptual), you practice the core skills (reinforcement) and then you combine what you learned from these 2 processes and you play the game (application). For most, the application aspect is the most fun. Many learning to code sites expose you to almost all the core programming concepts and only give you just enough practice before sending you to application process. However, in reality, the majority of time spent is primarily in the reinforcement process, then the conceptual, and then finally application. If you play a sport, you practice 6 days a week and then you play on the 7th. The better you practice in the first 6 days, the better you will perform on the 7th. The conceptual process must be sprinkled in more gradually with advanced concepts because advanced concepts are heavily reliant on the skill gained in the reinforcement process. The reinforcement processes combines chunks of conceptual knowledge with repetitive practice. There’s also thorough evaluation throughout of the level of one’s skill in sports by a professional, this is lacking in most learning to code sites.
I eventually found a program that provided a heavy level of reinforcement, with deep conceptual curriculum and a great evaluation process.
I found a self-paced program that taught the fundamentals of programming with Ruby (without any frameworks), was affordable and emphasized learning to mastery and focusing on “things that don’t change”. The program dauntingly states that it would take 1200–1800+ hours in total. After completing the first free course and improving my study skills, I decided to follow the long path laid out by the program.
This time was spent in the program’s free prep course, to evaluate if it was the right fit for me and also to learn basic programming syntax.
“Wax on..wax off” — Mr.Miyagi
During this period I primarily learned and practiced the Ruby syntax and developed good study habits. Basic programming constructs like variables, loops, iterators, string, integers, booleans, arrays, hashes, methods, and user input were covered. I did 100+ exercises in order to learn basic methods and gain a basic level understanding of these concepts. I learned how to read documentation and find answers to my questions. I learned the command line, how to navigate file structures, edit my environment and also how to use Git. Compared to learning a spoken language, I was learning what verbs and nouns are and trying to read and write simple sentences at this level. I wrote code that generally was 1 or a few lines.
At this level I started the program’s first paid course . During this period I did ~250 coding exercises and worked on 4 projects.
By the beginning of this span, I was reading and writing code that could be 5–10 lines. Much of this phase was continuing to utilize all the concepts covered in the first 100 hours while also developing a better understanding of using data structures (arrays, hashes), problem-solving (algorithms), and learning iterators and nested iterations. Some of the core concepts I learned common across all object-oriented programming languages were variable scope, variable assignment, mutation, and the return value of methods. This could be called the debugging and basic algorithms phase. I could read and write sentences before, but by the end I was reading and writing short paragraphs. Overall, I was honing procedural programming and understanding evaluation strategy at this level. By the end I was writing projects that were 50–100 lines of code.
Here is where the program started to differentiate itself with the depth in curriculum and assessment requirements. At the end, I was required to take a written assessment that tested my knowledge of these concepts thoroughly and in many cases my ability to break down code line-by-line while explaining the code using proper programming vocabulary. I also was required to pass a coding interview assessment similar to those given by actual software firms. Passing any assessment in the program required an A- grade or higher. I passed both.
Within this period I started the second course and learned the OO(object oriented) concepts in OOP (object oriented programming). Whereas before my programs were like a Jenga game that could unravel whenever I changed 1 piece, I now learned to create modular programs. If I needed to add or remove a feature in my program, I now could alter it without it breaking large aspects of the program. Common to other languages, I learned about classes, objects, OOP, accessibility levels, encapsulation, polymorphism, composition, and more. I also learned how to express point of view in my code. At this phase I wrote programs that were 300–400+ lines of code. I built more advanced features for projects. I could now write a 1 or 2 page paper. This phase really emphasized my understanding of what OO is in OOP.
I passed my next set of assessments as well. Some work I completed during this phase were three of the same projects I did in the first course, except using OOP principles this time. I also did dozens of exercises specifically focused on understanding OOP.
At this point, I’m now in the last part of learning fundamentals of a language. I’m now in the third course of the program covering testing, closures, and packaging code into bigger projects. I learned how to build my own iterators/loops. I can now create general methods that leave the implementation details up to the user. If I’m writing repetitive code, I can save it and make it reusable in other parts of the program. I can now also test my code to make sure that it works properly by using assertions.
Wow, looking back that seems like a lot of work, huh?
- There were many times I felt I wasn’t up to task, but when I continued practicing and learning, I kept getting better.
- There’s still a lot I don’t know. I’m intentionally sticking to the path laid out for me by the program so far. The deeper you go into a topic, like Regular Expressions, for example, the harder and longer you have to study.
List of Common Concepts Learned
- Version Control Systems (Git)
- Command Line Interface
- Object Types — Arrays, Hashes, Strings, Integers, Floats, Symbols, Ranges, Booleans etc.
- Regular Expressions
- &&/||/! Operators
- Working with files
- Flow Control
- Return Values
- General Problem Solving & Computational Thinking
- Procedural Programming
- Variable Assignment
- Variable Scope
- Variable Types — Constant, Local, Instance, Class. (We deliberately did not use global variables.)
- Object Evaluation Strategy (pass by value, pass by reference value, pass by reference)
- OOP — Polymorphism, Composition, Encapsulation, Inheritance
- Class/Instance Methods
- OOP keywords — include, self, super
- Error Handling
If you’re interested in taking the same path I did, check out LaunchSchool. Use my referral link here and get a $50 discount for a paid course. This article was my own unsolicited opinion. Some people may go faster or slower.