I have just completed my first module: The Principles of Programming. As a novice, I can tell you that it’s hard. I didn’t think by any means that this particular aspect of Computer Science was going to be a walk in the park, but I found that I had to try and adjust my way of thinking in a big way. Here are a few of my initial reflections on learning how to code from an absolute beginner’s point of view:

It Takes Hours of Practice

This one wasn’t too much of a surprise to me, but still an important one to point out. If you are expecting to complete a 3-hour course and come out of it an expert programmer in your chosen language, then that would be very naïve of you. Or even just to come out of that as an inter-mediate I think would be a stretch. What I have noticed so far, is that the more practice (and by practice, I mean trying to solve questions and not following a tutorial that tells you step-by-step what to type), the more you will start to notice similar patterns in how to achieve your desired outcome. As with any subject, the more problems and answers you are exposed to, the more capable you will be at building new programs and tackling problems. Ultimately, the only way to get there is through lots… and lots of practice.  

Attention to Detail is Key

The funny thing about programming is that correcting mistakes (debugging) is such a massive part of the skill. Being able to understand why your code isn’t running is imperative- and you can only achieve that if you have the focus to pay attention to small details. The other funny thing is that when you do make some mistakes- the IDE (the environment you write code in) actually explicitly tells you what you’ve done wrong, right down to the exact line (it sometimes even highlights it in red for you). However, this is not the end of the story- the attention to detail comes into play when you find yourself having to deal with logic errors. This essentially means that the code can be run, but it is not performing the intended purpose or output.

This is where the hours of reading, re-reading and laser-sharp focus comes in. The mix-up of a more-than and a less-than symbol becomes the pivotal difference between a functional program and a flop. And trying to find something like that is comparable to looking for a needle in a haystack at times. So being able to analyse each character of your program all the way through is sometimes a must to get your desired outcome.

It’s Hard to Get Your Head Around Some of the Concepts

A lot of concepts and principles in programming (and computer science in general) are highly abstract, and I have found it difficult to figure out what I’m actually doing sometimes. I may have run a program successfully… but do I know what’s actually going on deep within the computer that got me there? Not a clue. I have especially been finding it hard to grasp the ‘Object Orientated Programming’ concept whilst learning Java, and the mind-field of classes, methods, objects and instances. An effective way I have found of getting these things clear in my head, is the use of analogies. I found myself finally starting to understand the OOP principles when it got explained by using the popular computer game: The Sims, and the interactions between the different characters and use of private and public actions. You can find the link to this helpful article if you click here.

I don’t think this element should put you off of learning how to code, just be aware that you may not be able to grasp an understanding instantly- and that’s okay. You just have to accept that this will come with time and lots of practice.

You Improve Your Problem-Solving Skills

I am definitely guilty of not applying logic to many situations, and perhaps letting other things (emotions) take the lead on decision-making. But a strange and maybe advantageous affect I have noticed through learning how to code, is that it definitely drills into you a sense of following a logical structure when problem solving. I had a tendency before of analysing the entirety of a problem in its original state, and sometimes the sheer enormity of the task would make me feel overwhelmed, not knowing where or how to begin. However, through programming, I have learnt the important of tackling problems one step at a time. To give an example, we were given an assignment to code a Connect4 game using Java. This task was intimidating at first, but I decided to map out all the small incremental steps that would produce the game. Each evening I would focus on achieving one small aspect of the game- whether that was just printing out the board to the terminal, processing input from the player, or checking for a win. This change in my approach to problem solving was critical in allowing me understand the importance of chunking up a task to make small and consistent progress over time.

There is Never One Right Answer

This is one thing I was quite surprised at. I had always assumed that programming a computer was quite an exact science with little room for manoeuvre or deviation from a specific set of instructions. However, I was quite shocked to learn that you can in fact be quite ‘creative’ with your code, and have a lot of different ways to get to the same output. As I mentioned previously, there is an element of logic and best practice to the process of writing code- but everyone’s logic and thought process is different. So it is actually quite encouraging to see that neuro-diversity is celebrated to an extent, because of the fact that there are so many ‘right’ answers. Knowing this has made me feel much better about diving in head first when programming my solutions and being less anxious that I have gotten something wrong. I have noticed a sense of general curiosity from other programmers in sharing and learning from other people’s solutions and approaches.