I've been an educator for 9 years now. I've taught 6-8th grade science and math the majority of my time after starting off with substitute teaching and student teaching in elementary schools. I'm by no means an expert in anything when it comes to education but there are a lot of things I have been able to apply to my own learning as I look to enter a new phase of life as a developer.
In teacher land, there are a few people who are fairly prominent voices when it comes to the actual practice of teaching and one of them is John Hattie. He has written Visible Learning for Teachers, which focuses on teaching strategies that over the years have been found through research to have the greatest impact on students, regardless of factors such as the location of a school, the age of students, demographics, teachers, etc.
Basically, it's all about the high-impact methods teachers should focus on to help their classes do their best. It compares strategies like teaching how to take a test and compares it to other strategies, such as getting feedback. With that example, feedback is more meaningful so it should be given more of a focus. Its kind of like...trying to memorize every array method that exists vs. knowing map(), filter() or reduce(). The three of those could basically replace all the others if you know what you're doing, so it's probably better to really focus on understanding those. (Obviously that's more of an opinion).
I am going to be looking at the top 5 and bottom 5 strategies for instruction, as outlined by Hattie's research, from my perspective as an educator as well as someone who is self-learning development. Hopefully this can help others develop new strategies as they go through the process of self-learning, and perhaps even avoid some common pitfalls.
Direct Instruction is a reference to what we are all so familiar with, teachers standing in front of the room talking or somehow teaching something directly to the students.
There is a lot of direct instruction available when learning to code/program. Think of this website, or the many youtube channels and tutorials out there. It's one of the best ways to get information (that's pre-vetted/summarized) quickly with examples along the way.
As a teacher, direct instruction is difficult to manage because it assumes that whenever you start instructing everyone has the same starting point in terms of knowledge. We often have to answer questions along the way for the students who advocate for themselves and ask for clarification. If you're learning on your own, you have to self-advocate There is a wealth of information, but no one immediately available to clarify if needed. You'll need to find resources, like a mentor, a meetup group, or a slack channel where people will help you out!
Obviously, taking notes is note taking, but the "other skills" are things like reviewing flashcards, quizzing yourself with websites, making acronyms to remember...stuff like that.
There are a lot of opportunities for these strategies when learning development. There are even great tools like markdown that can help you to take notes directly in text-editors. It's not that the development world needs more help in taking notes and studying, but it's for someone learning to completely avoid doing this at all! After all, there is a wealth of great documentation out there that essentially allows us to be lazy and not take notes on anything because we've got all the resources already written out for us. The difficulty with relying on this, and the reason why note taking is such a high-impact tool when learning is because it forces the person taking the notes to summarize concepts in their own words. Doing this forces you to think about what's going on. I find that I can remember far more when following along with tutorials if I stop and take notes as I go. It's one thing to code along, but simply jotting down a few notes to yourself at the end of a 15-20 minute tutorial can help you mentally revisit the entire process and make sure you truly understand what was going on. Personally, I use markdown files in projects if it's directly related to the project but I also use Notion (the most amazing app ever) to record notes I might want to refer to more long term. It's great because you can embed links to the actual documentation as well as insert code snippets. You can check it out here and get a credit for $10 if that sounds neat to you.
Spaced practice is practicing something regularly, taking time in between sessions.
Luckily, this is an easy concept when programming and it's very easy to actually do in practice. When building projects, they typically takes days or weeks and you are repeating aspects of it over and over again. I think of creating React components and using Apollo queries and mutations. (I'm doing this now) In a simple app you might do that 20+ times over a long period of time, so it helps to retain how everything works when you do it day after day.
Another way we can implement spaced practice is completing challenges on sites like codewars, or playing games on sites like CodinGame. They might be simple challenges, but regularly solving puzzles like the ones on these sites can help you to keep aspects of programming fresh in your memory you might easily forget otherwise.
From an educators standpoint, Hattie speaks of giving timely feedback, but from a learners standpoint it's good to seek out feedback on out work.
This is actually a difficult thing to get when you are learning on your own. Obviously in a typical school environment it's normal to give/receive feedback on you work regularly, but when you're teaching yourself you actually have to seek this out. One thing I have done for this is to make sure I got a linter set up. It's also great that most front-end frameworks include great error reporting. Those provide instant feedback to what you're doing...wrong.
Another way I have sought out feedback is submitting my projects on forums, such as the one on freecodecamp, or writing posts here to see what others have to say. It’s a great way to see what others think about your projects.
Metacognitive & Problem Solving skills include things like goal setting, evaluating yourself, and responding to setback.
You can find many "cycles" of metacognition and problem solving online, but they essentially all boil down to a process that involves making a plan, setting a goal (Better yet a SMART goal. Specific, Measurable, Achievable, Relevant and Time-bound), attempting to tackle the task and reflecting on how things went before starting again.
While learning development, these skills are very important. It's easy to go off and explore a million different frameworks or processes without actually getting anywhere meaningful. I think this is one of the reasons that the best way to approach learning any avenue of programming is to try and actually build something yourself. If you have a goal in mind you might find yourself stuck while trying to build some application using React, or Angular, or PHP, or whatever...but when you stop and reflect on where you need to get to you can cut out a lot of the extraneous clutter out there and focus on solving the specific problem in from of you. That might actually mean learning a substantially large new skill, something like user authentication or managing permissions, but even that is moving you forward towards a purpose.
This is an ineffective method of teaching because it often places students in the position of making decisions about their learning before they have the wherewithal to make informed decisions about what to study. It’s very similar to the thoughts I had about why developing metacognition and problem solving skills is important.
While in a position of self-learning, it’s important to think of why having control over your own learning can lead to making learning a more difficult process. Generally, as someone new to a field of study, you’ll most often find yourself needing to make decisions on what to learn without know what’s actually important. After all, you don’t know what you don’t know! It’s the perfect argument, yet again, for setting goals, evaluating yourself, and seeking out feedback from others so you are not relying solely on yourself.
Problem-based learning is the notion that student will learn if you present them with a problem, and they have to come up with ways to solve the problem. There are actually many ways this manifests out in a classroom environment. Sometimes it works great, and other times...not so much. In my experience the reason that it often does not lead to an effective way (or not as effective as other methods) of learning is that we are always more comfortable solving a problem with skills that we already have. In the world of development that means that being presented with a new problem doesn't necessarily mean that we will learn new skills just by taking on new projects because we will default to solving problems the same way we have in the past if possible. It's because of this I feel it's important when working on new projects to also choose something new to try out. Try a new framework, a new way to authenticate users, or add in some feature you've never built before. Doing that can help avoid the problem-based pitfall of just solving new problems using old skills.
Luckily, this doesn't really really have much space for implementation in dev land. The one way I see this showing up is whenever I look into what's involved with preparing for whiteboard interviews. I think there are many resources out there that teach you certain ways to approach the problems in a whiteboard interview, or key phrases to mention or use such as Big-O, but at the end of the day the interview (like a well designed test in school) if really just meant to measure your understanding of the content. I think if you know what you're doing when you are developing, you would also be confident in the interview situation. Of course, you actually need to know some things about how whiteboard interviews work, but that shouldn't be the focus.
I don't see this much in dev lend either. This is the idea that you should teach things differently based on someone being a visual, auditory, or kinesthetic (movement) learner. It turns out that while this can help people remember or learn things, it's not as important as many other factors. I think that as a self-learner you always have the benefit of seeking out the types of media, reading materials, or strategy that you choose when gathering more knowledge anyway. Since you are seeking out the learning yourself, you'll naturally gravitate towards what drives you.
Inquiry-based teaching is really great (in my opinion). It's often not as effective as other strategies, but as someone who teaches 7th grade, it's great for combating a lack of interest in a subject. An inquiry based project or assignment usually starts of with some question they might have. A lab in science is a perfect example because students might be trying to carry out an experiment to answer a question they have about something thats been discussed in class. While it's kind of difficult to manage in a classroom (lots of management to allow students to go explore things on their own!) I think this is actually a great way to learn as a developer. After all, basically everything I've learned has been inquiry based!
I'm not sure that there is too much of a takeaway to directly apply to your day-to-day dev life here, but I thought someone out there might be interested. I feel as though even the process of writing out the 5 least effective strategies made me think about how those strategies differ in their effectiveness from the perspective of a middle school teacher, to a learner myself.
One interesting thing I reflected on throughout writing this was that, in general, the bottom 5 strategies all place much more responsibility on the learner/student. I think this is probably one of the reasons why I read and hear so often that learning on your own can take a lot of time an commitment and drive. (Or better yet, Grit, as teachers are all the rage talking about these days)
If you're interested in finding out more about Hattie's research, here are some links: