1. Draw a circle 2. Draw the rest of the owl

"The master has failed more times than the beginner has even tried."

no struggle = no gains

Can confirm. Throughout my school years, I learned more when my teachers made intentional mistakes and explain why doing that was a mistake

How I learn programming is: - I want to build something - I learn about the thing I want to build and it’s surroundings - I try to find out how to build the things I need - I learn a ton of (at first) useless half-correct things along the way -I build the thing (or I fail to build it)

I studied programming for two years and didn’t understand. I learned better by looking at the end result. Then I broke each component of the architecture down to its simplest. Started with the end and worked my way to the start. Kind of like trying to build a tv for the first time by taking apart all the parts of the tv and understanding each component.

I think there's room for both. Showing a final result can give an idea of how a concept is supposed to work. It builds understanding but not skill. Just trying stuff until it works builds resilience and skill but if you don't understand why what you made works you're missing out. You might also keep doing stuff in inconvenient ways because your working in a way that's locally optimal but globally subpar. So I think there needs to be a split of 30% new concepts cleanly introduced and 70% unguided or lightly guided practice.

I still didn't see anyone else teach like Jeffrey Way from Laracasts. His approach is pure learning. He builds on the screencast the wrong version, shows you the error, then fixes it (kinda), shows you the way, and then improves the fix again. He is just brilliant.

How I learned it is to do the step by step solution and then start figuring out what means what. And tweaking things try and adjust the solution to fit my current problem better. After a few of those you have a general understanding of how things work and when you do the proper way of learning then it's a lot faster. But this keeps my interest high

It’s important to see the final result when you are first learning. This is because when learning something new, most times you never understand the “why”. The end result gives you an answer to this “why”. Then when you dive into the code and learn more about the individual parts, the “how” becomes clear. Next thing you know you have a solid end to end knowledge of an application.

Why would I rebuild X?! Elon dominates the market, there is no way I could compete with him

I agree 100%. Most learning comes from making assumptions about a system and doing things that rely those assumptions, and looking back at those assumptions to reasess your understanding until you stop failing. True understanding does not come from memorisation but from making assumptions and repeatedly interrogating them until your understanding grows to account for most nuances and edge cases

As someone learning to code this 💯 facts . And you have to read the damn docs. .

Your energy and enthusiasm are contagious. Love it!

that's absolutely true. i found that by myself, was more productive if i only had what i need but not the result, this way i can work my way to the result.

This is correct and it applies to a lot of stuff, it's how I learned Solidworks really quickly. Went through a youtube tutorial series, and I'd always pause the video and try to draw/model the thing myself, then after I was done, I'd watch the professor do it. The first part was where I really learned my way around the software in-depth and independent problem solving, then watching the professor do it after showed me where I messed up, best practices, and shortcuts and techniques I could've used.

One way to get understanding is through failure. You let reality tell you you're wrong over and over again until things start to work. And the hope is that things work because you understand what you did. Another way that I honestly think is better and almost never addressed is by starting with the right answer and trying to break it. You look at each step and think of all the ways you could do it differently and then see if they work or why they don't. Basically, you go backwards in an attempt to prove to yourself the "correct" version is actually correct.

So simple yet a deep philosophy

That's one way. Copying even understanding what you copied has little value. On CS50p for example they teach you the base case, and then to solve the problems you'll never make it with that base case alone, you have to think and go read the python docs, libraries docs, whatever. Each problem is a struggle, but it feels so good when you finally solve them.

this is absolute facts. the struggle is where you get the understanding. the caveat though is you can get stuck in bad habits without someone to help you optimise your cobbled together solutions.

I like to be able to answer where why and how before starting to code, building a solution design proposal before moving to the implementation works for me.

This has an element of truth, but is dangerous to follow to an extreme conclusion. Throw them in the deep end, sure, but make sure they have working arms and legs first. The first method is great for getting up to speed on specifics when you know what you're doing generally, the second builds character - but only if you have those basics down first. You have to build up both parts of your personality, passive and active motivation and perception.

Love it. We only learn from being wrong. The struggle is real, and worth it.

Issue with programming is that you can easily struggle, waste time, have mental anguish and not learn anything new.

I think it matters at what stage you are. I've found that when beginning to learn a new language and you're learning the basics, it helps to do a bunch of projects just to get used to the language, and then to tackle something like described (i.e. to the point where the language and its syntax isn't the barrier, but what you are trying to do is.).

I’ve done a bunch of tutorials, but am currently working through the second half of nand2tetris and it’s ways better. They say “here is how our assembly language works with the virtual hardware. Now make a multiplication program” and I had to figure out how to use the three available registers and do it out on my own. And then I took that and made something to do integer division. Way better than most tutorials I have had.

My teacher taught us the very basic principles like what strings are, what for loops are etc, and along the had us practice things with no real guidance other than, build this, you should know all the tools you need already, you could get help if needed, but she was great about not giving answers but a gentle nudge in the right direction, i loved her.

There's a construction set called Meccano by the old toy company Hornby, this exact understanding was known to them at the time of construction (it's as old as 1898) where they would intentionally fudge the instructions with mistakes, so that the individual creations would become more unique. This concept is lost to time as people are hungrier and hungrier for learning but refuse to subject themselves to any failure or strife.

Yeah.. this can be really tough, especially early on.. but it is the only way to get to making what you actually want

i learned programming mostly by step by step direction when i was a kid. it worked for me for most of it, but my troubleshooting skills DEFINITELY came from me screwing around and making tons of mistakes with those directions. You still learn, especially when even following the directions doesn’t work. Then you gotta figure out what dumb crap you did to mess up, then you learn troubleshooting. my learning path is unique though. i am autistic and have a severe special interest in programming. i was so determined that i would destroy my sleep and school schedules and pretend to do schoolwork when i was actually programming

I have never seen such an educator who goes to the underpinnings of learning, eager to follow you to learn more.

That is the exact approach in the current course I am attending. I have never learned so much so quickly and retained it.

It ain’t learning if you ain’t fail

I'm a hobbyist, and still don't understand how people design programs. I just bang my head against the keyboard until something approximating my intent happens. I've always learned better with the 'over the shoulder' approach

You add value to people's experiences. That's something I like about you. Yes, learning by doing is the most effective way to acquire experience. Look at the problem. Break it into steps. Think from there. Good work, keep it up!

When he started explaining I thought he was gonna tell us why AI will be able to do this as well if not better and faster.

I know that prime speaks with an authorotative voice, but actually people have studied what works best. They've looked at high-schoolers learning to program (I think in the Netherlands), and split it up in three groups: - One was mainly focused on learning code through reading, i.e. they read code, discussed code, and then implemented new stuff. - One was mainly focused on writing code, i.e. the thing that is described here. A bit of guidance, but mostly trial-and-error - The third group was a mixed group with both, but still a large focus of intentional reading. When it came to performance in tests afterwards, the reading and mixed group were fairly close in performance, but the mixed group won out. The "mostly-trial-and-error" group did the worst of all. The conclusion of the study-authors was that too much emphasis is placed on writing of code, and trial-and-error, and too little of just reading comprehension. We need to do more stuff like "explain what this piece of code does in your own words?" and also things like "why does it have this bug?" "which method implements this?" "describe this function in your own words" I think, yeah, just following a tutorial is stupid. But reading, the "clean solution by a master" is something that is undervalued in programming courses all over the world!

I learned to programme by building games in batch back in the early days of youtube. There was very few tutorials or guides on games in batch, but I thought it was really cool, and eventually worked my way up to other languages. I learned because I had to figure out the code myself.

That's how I feel on learning C with K&R. First i try to make the stuff that is vaguely explained in the book -> fail -> read the example code -> take notes on the stuff you did wrong. Also the exercises at the end of each chapter are a good way to get stuck for a week.

i think at the very very beginning the first method can be useful, just to give some basic framework, but you should start doing the second as soon as possible or maybe even in parallel

that's right, but I would say there is value in executing a known plan too. Especially if someone explains you the idioms in the solution, etc. The point is that these are different things: learning something, developing, operating it. And it is really overwhelming to overlap them, to do each at 100% at the same time. Especially if you have deadlines. You want to learn things separately as much as possible, then apply what you already know to some extend in development. Yeah, there there will never be a perfect split. You will certainly need to learn in the real project. But it is possible to learn ahead, and it will make your life much easier if you go into a real project with some basics learnt in a simpler situation.

Currently going through the process of learning how to code. The places with higher quality teaching use a blend of both. They usually do the first method of teaching you step by step. At the end of a section they use the second method, usually something along the lines of, "now use what you've learned and build some stuff out of it like x, y, or z." Imagine teaching gravity by dropping apples on student's heads and then asking them to create a mathematical proof for what just happened lol

exactly that. My mentor told me what an array is, different data types for variables/functions, what functions and parameters are, how to create a class, how to build a constructor for that class and so on and so on .... In the end he told me "and now, here is an actual project im working on right now, i can't be bothered to do it myself, but i think for you it would be the perfect training case to work on". I can now do this stuff with my eyes closed. Edit : I knew most of the stuff i mentioned earlier before my mentor got into those things with me, but the bottom line is, that i learned those things "for the sake of repeating it", i never really got into using those principles on a daily basis. Through him i developed a natural understanding on how to dissect the amount of states within a function for example, or why it is so important to use Type- over JavaScript if your building actual React components. These are lessons you are not going to figure out yourself without hands on experience, a lot of Junior Dev's write singular functions and write everything in global lets- or constants, let alone useful documentation. Properly using function/variable scopes and reusable class components is an important lesson.

In my OS class had to build specific components. However, understanding a mid/large scale system and tweaking it is also highly valuable on a real job; not as easy as it seems and many times more difficult than to start from scratch. Looking at others people’s code is how you learn as well. You rarely do things from scratch. A mix pf both is ideal IMO

I've been looking for a way to put this into words about a year now thank you

Starting Forth: F stars Shows you how to make F stars step by step. He doesn't explain, now complete the word 'FORTH' with the foundation given. That first chapter is really amazing as an example of the power of Forth.

The way I've been learning is the first thing that you said. BUT there's a challenge at the end of each stage that revises what you learned during the stage that you do yourself.

Dam Schiffman sort of does both of these. He will make videos where he’s live coding some concept and actually figures out some things on camera rather than just showing the step by step. This allows at least some of that learning process to be done even if the learner is just copying what he’s doing. I think for complete beginners this helps a lot and shows them that even an experienced programmer goes through this process over and over, and they can just do that themselves

The way i learned from videos who showed you exactly how to do a specific thing, is i would than break down every component of the code and than figure out HOW it works and WHY it works, than build something different off that code component. Kind of like reverse engineering, that way i retain more information about it, and i gain new coding techniques that i can implement into my future projects. Its extremely helpful but it takes a long time to figure it all out

If you swap programming for cooking I think there are some issues following this approach if you take it too literally. However, avoiding too much hand-holding and micromanaging is certainly a good thing. I would recommend starting with full instructions and slowly leaving out larger and larger steps for them to figure out.

This is why when I create something, instead of using prebuilt methods by the language lets say “sort” usually when I first started I create my own version in for loop with diff sorting algos

That’s literally how I teach myself pretty anything. Rarely do I do courses on stuff, I mostly just start trying something then inevitably fail and reading up on my precise point of failure and fixing it.

This works so well for me. It’s better if a teacher gives me the tools and shows me how to use them, and then sends me off to build something with it Rather than giving me instructions step by step how to build something and I have no idea what tools I’m using or how to use them, I’m just copying at that point

First you learn the tools, then you learn how to use the tools to make small things to understand which tool works in what case. Repeat, play and get familiar with tools so that you can express basic ideas with them. This is important as then you know how to use the tool to shape your ideas in a way that can be created. Then you take a problem, break it down in sub-problems you can solve. If subproblem is too slow or too difficult, look for solutions or clever tool usage and reinforce your understanding of the tool used. This "playing with tools" is the process of learning. Repeat is a way to reinforce, solving better problems is the application + feedback loop which deepens the concept. They are not mutually exclusive, rather they comes one after the other. Skip either and you would not gain proficiency

Is this before Thor got his second puberty and his voice dropped?

SoloLearn does a cool way of teaching coding. Either drag and drop the code to correct spots, type in missing pieces, or giving you a playground to manipulate code to see how it behaves. At the end of each lesson there is a problem you have to solve so ot gives you practical examples of each concept. You cant move on until the problem is solved.

This is true. Really fortunate I had a great mentor of a lead back then on my first job.

Im in a class with a bunch of other guys where we do electronics, and currently its all arduino programming, luckily the teacher is actually somewhat doing it in the right way and giving them problems that they have to solve on their own. Im bored af as I do programming as a part of my Apprenticeship soo, but its great seeing how others learn it and also helping them.

I never got it in school. Later in life, I decided to try learning it again, so I tried all the books and KZfaq tutorials I could find...still didnt get it. Then, a friend got me into arma. I loved the game and became curious about the creative possibilities the scenario creation afforded. I picked up the basics quite quickly. Because no one is saying "do this this and this to create this", I was self teaching by finding an incidental, self-created, problem; and working out not only the coding around it, but also different ways of applying types of structures to different problems, and later how to optimise. Now that same friend (who is a professional programmer) asks me for my scripts and functions! I then found that going to other languages was a breeze, and I was able to pick them up quickly and create some awesome things. Long story short, the benefit of self education is enormous. Finding your own problems and finding your own way around them with the assistance of the available resources (forums, programming tutorials, etc.) provides the most robust skill set you can achieve.

Wow. This is a perspective shift. Now on Leetcode, I’m going to look forward to the “Wrong Answer” status as a sign that I’m learning! And the “correct answer” is simply just the final result.

I agree, you should just make X as learning practice. Some source code was even published not too long ago, so when when you're ready you can check your code with the original.

I learned by going head-first into projects and then studying pre-existing opensource programs to figure out what it did/how it worked, only using documents or youtube if I got stuck.. it worked pretty well so far. Also, sure, this probably isn’t the best way to learn since everyone that makes the open source programs are at a different skill level, so I could be looking at a complete beginners program or a professional. I didn’t care at the time though as I just wanted to learn basics. Sure, there’s probably a better way to do things but oh well, I’ll learn those as I go.

Can you please provide us with more tips like this im honestly really counting only on you on my journey of learning , i watch all your videos even tho most of time i don’t understand what you’re talking about but i make researches on topic but please keep on giving us more tips , i hope you can read comments even tho i know you are always busy building and reading about amazing stuff , keep it up !!

exactly. This is why, even if you poured a year into "doing courses" - you still can be completely confounded when you try to build something from a scratch. Use course to familiarize with concepts and fundamentals, and then start your personal project. Also, when you learn something new while ALREADY having experience with your own projects and mistakes - you gonna learn A LOT more and much more efficiently.

The most important part in the middle is to show you HOW and WHAT to look for the stuff you need to do X. This is the issue I see everywhere. Point me to the somewhat vague but right direction and I'll do the rest by myself and go through the learning process. But if I don't even know where to start, I simply won't

The first one falls under tutorial hell. Second one is actually learning.

That’s why building projects are beneficial and so vital to ingrain knowledge.

Yep, sometimes when you read KZfaqrs code is like how the hell did they think of this perfect piece of code? But actually they iterated so many times

Thats why fundamentals is the most important part of learning.

I certainly agree with the point hes trying to make. but everyone has to start somewhere. depending on where you are in the learning process, generally lesson 1 of some completely new topic has to be directly shown to you before you can figure out other problems yourself im a comp sci grad with 2 years experience and I still ALWAYS have my first experience with a new technology be a 1:1 find the answer exactly how I want it done. then from there I work on doing more and more myself without external sources

correct, this is how I learn by myself, by trying and failing over again till i get it right or just search for the answer if I cant figure it myself.

To me, coding grows exponentially abstract. Seeing the bigger picture is a must. It's about absorbing a large amount of specific information, compressing it into an idea, applying it to something useful, then moving on to the next new topic.

I always try to find the tutorials that just gives me the working "simple" code but explains why it works along the way. Then i find I learn best by rewriting the code on my own without the totorial after I've studied it enough to understand it. Typically making adjustments along the way to better suit my use case. But i agree that just following the tutorial without any thought on your part makes it impossible to learn.

Trial by Fire is the best way to learn anything, I think. I was given a job as a Linux admin 7-8 years ago and knew 1 Linux command (ifconfig if you must know). I learned rapidly how to be a Linux admin, probably helps that I was a Windows admin for 12 years prior so I had a solid background. I'm a mixed Windows, Mac,, iOS, and Linux admin now days. I teach my junior admins by giving them a task with specific details and deliverables. They either learn it or they fail.

That's why I do retro coding. A lot of pain, a lot of learning.

I actually like best those videos where the instructor runs into a problem and solves it live rather than edits it out.

The amount of failures I encountered doing a simple Pong game all by myself after "successfully" completing courses/tutorials was astonishing.

one of my profs, which ended up being my advisor during my master's program, did exactly that. All the other embedded courses were like 'you put this here and this here and this there, tada, now you have your robot moving'. His approach was 'Ok, we have this component that needs to do this. We use these concepts A B and C to implement functionality. Now go and implement' - and he'd have this huge codebase for a robot that can do all kinds of stuff with functionality left out to implement during the course.

the best way to learn is to have an end toy application in mind. then use the documentation and tutorial to achive the "application" you had in mind.. you will get a general idea of the language/framwork/library/api capabilites and the gaps it has and it keeps you motivated to learn..

I learnt and kind of tried to understand all the syntax of CSS then I was recruited to solve an issue which boggled a good amount of people. I was a fried popcorn infront of those lads. But I just picked up the good ol' method of RnD and hit and run method. I just began rummaging through the components of script and finally in 3 days I was able to diagnose the problem. So yea programming can only be learned if you are wanting to solve the problem.

This video is like a ray of sunshine on a cloudy day.

The way you suggested to learn how to code is how I learned to code. The most astounding thing I learned was I just learned how to learn.

I had a lot of my core coding classes during the peak of COVID where they moved it online. I really struggled because I almost zero input from my professors and kind of like how you're explaining here, I never really learned anything I just found out how to paste solutions... I passed but I felt like I knew nothing.

My simple rule, See the end result you wanna achieve and then break it step by step either from end result to the starting or starting to the end

Well, you dont have to reinvent the wheel, you try to learn good practice

100% I would no way call my self a programmer, but I can knock out some tools, small scale things and trouble shoot and that's only because I took on learning how to my self, learnt the basics, came up with a project, made it, failed a dozen times along the way until it began to work. Thats enough to get you by, but what really kept me learning was refactoring and doing the same thing again but better with the new knowledge you have. Nothing is more rewarding then looking at some of your old code and seeing how far you have come and whipping up an old tool to be better (As long as you remembered to comment for yourself/others haha)

It's called scaffolding - it's essential for the learning process. That's why people and toys helped you with your first steps; why you went over dotted lines when writing or learning to draw etc.

That is the best way, someone should show you something, then tell you to try multiple things using what they just showed you

To be fair, the first approach does help if you already have some prior knowledge in programming. It is how i learned Java (after already knowing C and Pascal) as it outs me directly in the deep end, by blazing me through the basics to the things I'm interested in

In context of learning true, but for completing tasks one can’t reinvent the wheel every time. I can’t write the numpy array library, but I can learn how to use it. Programming is built on “final results “, I might not understand the context though as it is a short.

This methodology is how I’ve learned nearly everything in my life, and now I make more money than two of my friends combined without ever going to college. Never doubt what perseverance can teach you.

THIS. I was "learning" js in the first way he explained. It felt like i progressed. Then i wanted to create something from scratch and saw i actually didn't learn shit.

Indeed, you learn by making mistakes, but getting help from others is a nice thing and it can also help with learning.

Back in my day.... we bought the language book and reverse engineered programs we found on the second hand computer our parents bought us at a garage sale.

Free Code Camp does the best version of this that I've seen.

I learned by first copying exactly what they said, it not working, then copying exactly what someone else said and using that to fix the first thing. Fucking around with why it did/did not work and messing around with everything, until I learned all the parts and how to use them.

This is also the reason why there are so many "smart" frameworks on how to be more productive and whatnot. It is not the final output that is what makes you better, it is the process of discovery for that one person. Learning is the journey. Final answer is just information.

The thinking is what doesn't happen much in the learning, it's mostly memorizing

the most sensible guy on youtube advincin programers

Agreed, and this should be the case before you enter the industry.