How to ACTUALLY learn from Coding Tutorials (Step-by-Step Guide) || part three.

(If you prefer watching video: https://www.youtube.com/watch?v=XW9-7wn6KoA)

So we've prepared, we've gone through the tutorial, and now it’s time to review what you have learned. At this stage, you’ll be revisiting the same material for the third time.

And in this article, we will be going through some useful strategies and techniques to do so.

Effective Review Techniques:

1. Recreate the Project: Write down the steps needed to recreate the project from scratch. Or try to build it again without any help from tutorial or if it’s too hard, then you can cheat here and there, but mostly from you own knowledge. This will help you to internalize the process.
2. Enhance the Project: Try adding extra functionality to your codebase or app. This could involve implementing new features or optimizing existing ones, which will deepen your understanding and give you practical experience.
3. Mind-Mapping: Create a mind map of the concepts covered in the tutorial. The important thing here is to create groups of similar concepts, denote relation between them with lines, arrows and make sure to indicate the flow of information or steps and concepts through arrows. This visual representation helps you see how different ideas are connected and aids in memory retention.

4. Document Your Work: Write detailed documentation for the project you’ve built. This practice not only reinforces what you’ve learned but also creates a valuable reference for future projects. And to help you in this process;

   Here are some questions you should ask and answer to properly review the project:

   1. Project Overview:
      • What is the purpose of the project?
        • Example: "The project is a basic to-do list application aimed at helping users manage their daily tasks."
      • What technologies were used?
        • Example: "The project was built using HTML, CSS, and JavaScript for the front end, with Node.js and Express for the back end, and MongoDB as the database."
   2. Core Functionality:
      • What are the main features of the project?
        • Example: "Users can add, delete, and mark tasks as complete. Tasks are stored in a MongoDB database and persist across sessions."
      • How does each feature work?
        • Example: "When a user adds a task, it sends a POST request to the server, which saves the task in the database and updates the front-end display."
   3. Code Analysis:
      • How is the code structured?
        • Example: "The project is organized into separate folders for routes, models, and views. The server.js file handles the main server logic."
      • What are the key functions or classes, and what do they do?
        • Example: "The addTask function handles creating new tasks, the deleteTask function handles removing tasks, and the markComplete function updates task status."
      • How do different parts of the code interact?
        • Example: "The front-end JavaScript sends AJAX requests to the Express routes, which then interact with the MongoDB database through Mongoose models."
   4. Challenges and Solutions:
      • What challenges did you face while building the project?
        • Example: "I had difficulty implementing the update functionality for tasks due to unfamiliarity with MongoDB update operations."
      • How did you overcome these challenges?
        • Example: "I consulted the Mongoose documentation and experimented with different update methods until I found the correct approach."
   5. Learning Outcomes:
      • What new concepts or skills did you learn from this project?
        • Example: "I learned how to set up a basic Express server, connect it to a MongoDB database, and use Mongoose for data modeling."
      • How did this project improve your coding abilities?
        • Example: "It improved my understanding of RESTful APIs and enhanced my ability to debug JavaScript code."
   6. Potential Improvements:
      • What could be improved or added to the project?
        • Example: "I could add user authentication to allow multiple users to manage their own task lists and improve the front-end design for better user experience."
      • How would you implement these improvements?
        • Example: "I would use Passport.js for authentication and redesign the interface using a front-end framework like Bootstrap."
   7. Reflection:
      • What did you enjoy most about this project?
        • Example: "I enjoyed seeing the project come together and function as intended, especially when the database interactions worked smoothly."
      • What was the most challenging part of the project?
        • Example: "Debugging the asynchronous code in JavaScript was the most challenging part because it required careful attention to how promises and callbacks were handled."
      • What would you do differently if you started the project again?
        • Example: "I would spend more time planning the project structure and design before jumping into coding to avoid major refactoring later on."

5. Free Recall: One of the simplest review technique is free recall. Just take out a blank sheet of paper and write down everything you can remember about the tutorial. Organize and synthesize the information, and then use resources like ChatGPT, documentation, or the internet to fill in any gaps.

Another question you may ask is, how much time should we wait to do review after finishing tutorial?

So ideally, you should review the material relatively soon after completing the tutorial. It doesn’t have to be immediately, but don’t wait longer than a day or so. Even if you only perform this free recall exercise once a week, it will be immensely helpful, especially if you’re not doing any other kind of reflection or synthesis of your learning.

Discuss and Collaborate:

• With Fellow Programmers: Discussing the material with fellow programmers can provide new perspectives and insights. Collaboration often leads to a deeper understanding.
• With Non-Programmers: Explaining the concepts to someone without a programming background can also be incredibly beneficial. It forces you to bring more background knowledge and context around the things, that you are trying to convey. And they may ask questions that you hadn’t even considered yet !.
• And if you don’t find or have anyone, you can imagine you are explaining it to someone. Verbalizing and articulating things always helps when it comes to build higher understanding of the things.

Consolidate Your Knowledge:

The key is to actively engage in some form of review to solidify your understanding. Sometimes this review process will blend into preparation for the next concept or project you will be working on. Many projects have overlapping concepts and steps. For example, if you are working on three projects all related to e-commerce apps or web scraping, reviewing the first project will help prepare you for the next ones as well.

Don't Neglect the Fundamentals:

Avoid skipping over topics you think you already know. It’s easy to assume familiarity means understanding, but often, fundamentals need to be revisited and deeply understood. Most subjects I've learned in life became clearer much later on, when I realized the importance of those basic concepts and I actually had a very superficial understanding of those things. I always find myself going back to the foundational principles because they underpin everything else. And I am sure many of you had similar experience of sort.

Understanding the fundamentals, well makes advanced topics more intuitive and easier to grasp. There’s a reason why so many experts emphasize on those basics – they are the building blocks for everything that follows. If you have a solid grasp of the fundamentals, other topics become extensions of that core knowledge, making much more sense.

---

In a lot of cases when you are using a certain framework, library, programming tool, or even a programming language itself, it's crucial to understand the core principles and the specific cases where these principles play a significant part. These core principles form the foundation, and most techniques, tricks, and steps are derived from these fundamental rules.

In any complex project, there are numerous small components. These little bits work together within larger systems to accomplish specific processes and create the desired behavior for the final project or product. While it's important to understand these individual components, it's equally vital to comprehend how they integrate into larger systems. The more you understand how these systems collaborate to achieve certain goals, the more sense the individual components will make.

On the importance and process of review:

Reviewing what you’ve learned helps you see the bigger picture and clarifies how everything fits together. One thing you might want to do is to link this project to our previous project that you have made. This connection helps reinforce your understanding and shows how different concepts and techniques can be applied across various projects.

Keep in mind, these are just some basic ideas to guide your study sessions. You must exercise and use your own judgment and apply these strategies wisely. There isn't a single correct way to learn from tutorials. The best approach depends on several factors, such as:

• What You're Learning: Different topics might require different study techniques.
• Your Preferences: Some people learn better through hands-on practice, while others might prefer reading or watching videos and try to connect things in their head while doing that. And some may just want to draw out things.
• Your Prior Knowledge: Your existing understanding of the subject can influence how you see and approach new material. As it will be easier for you to build up on those things.
• Available Resources: The resources you have access to, such as friends, courses, source codes, and online communities are can also play a huge role.

And don’t worry, you don’t have to follow these steps every single time. Even incorporating these strategies occasionally can significantly boost your learning experience.

By understanding the core principles, recognizing the role of individual components within larger systems, and wisely applying review strategies, and by also using techniques and strategies discussed in previous articles you can properly utilize the most of the coding tutorial video that you watch.