As I’ve
been progressing through learning to code, I’ve been working my way through a
lot of tutorials. The trouble with tutorials is that, while they’re great for
showing you how to do certain things, a lot of your time is spent following
along and just copying the work you’re already being shown. Yes, you’re usually
being told why you’re doing each of the steps, but when your goal is learning,
how do you know if you’re actually retaining that information?
It’s a
challenging prospect, especially if you pick things up fairly quickly, to
figure out if you’re actually learning. Being self-taught, there (usually) aren’t
any tests to take, so I have to find a way to measure my own success. So, the
first method I came up with for proving to myself I was actually learning was
to skip ahead of the tutorial. I’d pause in the middle of an instruction to finish
writing the code the way I though it should be – it was very rewarding when I
got it right, and when it was wrong I felt I’d learned more – because I now had
a comparison of two different ways of approaching a problem, and that gave me
more information than simply being told how to do it right.
More
recently, I moved on to playing with designing some of my own projects. This is
very challenging because, unlike tutorials, there’s nothing there to teach the
right way to do things, and unlike with proper tests, there’s no way of knowing
if you even have the skills to accomplish what you want. I knew this going in,
but I found one additional unexpected challenge – my own desire to learn.
The
important thing to know about programming is that there is a lot of code that
has already been written – either built into the language, or that other people
have written for their own projects. Just about anything you want to do,
someone has either done, or has done something similar enough that you can make
minor changes to their code to make it work.
But, I want
to learn and prove to myself that I can figure out how to solve the problems on
my own. Yet, there’s no reason I should re-invent the wheel, especially when it’s
already built into the language, just so I can say I did it. On the other hand,
it’s an excellent exercise for testing my capabilities.
In the end,
it comes down to finding a balance between using what’s available and writing
my own functionalities. The important part, after all, is getting the code
effectively and efficiently written – and it’s just as important to learn how
to look up code for things I don’t know how to do as it is to learn how to do
it myself.
Check out my YouTube channel where I tell the stories of my D&D campaigns.
Also, make sure you check out my wife's blog and her website.
If there's any subject you'd like to see me ramble on about, feel free to leave a comment asking me to do so.
No comments:
Post a Comment