5 things that will make learning to program much easier

Learning to code professionally is in general not the easiest task that you can take on. In the past it might have been a simpler time. You had a programming language, a compiler and a few simple server configurations and that was usually enough to get a 'hello world' application up and running.

These days, things are much different. You not only have programming languages and compilers, but you might also have multiple languages and multiple compilers. Or you might have interpreters and transpilers to go with it. And you might even have a few pre-processors to add to the mix.

Learning to code in the modern age is difficult enough as it is, so don't make it any more difficult by doing the following.

5. Limit Copying

It's great to get inspiration or helpful guidance from someone else that you admire. But unless you come up with your own way of doing things, you are going to eventually hit a wall and you won't know how to climb over it without someone else showing you how to do it first. And that can be a problem if you find yourself working on complex applications at work by yourself.

Alot of what programming is, is the ability to dive in and to figure out what is happening in front of you. Once you get a general idea, you can then use your knowledge of the programming language to come up with a viable solution.

And that problem-solving mentality is what takes you from a good programmer to a great programmer. It's the primary reason why you get hired for a company. Anybody can learn what a for-loop does, but not everyone can come up with the right implementation of the code quickly and efficiently.

for (let i = 0; i < 10; i++){
   sum += i;
}

Compared to:

class BST {
  constructor() {
    this.root = null;
  }
  create(val) {
    const newNode = new Node(val);
    if (!this.root) {
      this.root = newNode;
      return this;
    };
    let current = this.root;

    const addSide = side => {
      if (!current[side]) {
        current[side] = newNode;
        return this;
      };
      current = current[side];
    };

    while (true) {
      if (val === current.val) {
        current.count++;
        return this;
      };
      if (val < current.val) addSide('left');
      else addSide('right');
    };
  };
};

Having said that, copy and pasting is a big part of being a programmer. You are encountering new unforeseen things on the daily, and odds are someone else on the internet has probably figured it out for you. But knowing what it is that your are copying and being able to modify it as needed is what will make you into a more powerful programmer.

4. Stay Updated

Code changes more often than you realize. New features are constantly getting added on a recurring monthly basis, and in that same light older keywords and methods are quickly gotten rid of. In technical terms, code gets deprecated once it has run its course. That process typically takes years however and there is little to no warning about what it is that is being removed.

And if you are not keeping up with the latest and greatest, then eventually you are going to find yourself locked out of the coding house.

As an example of just how much these technologies change, just take a look at the HTML standard list of resolved and unresolved issues. There is alot there and it is always changing.

I still know plenty of professional developers who code using code editors from 7 years ago and who avoid updating their frameworks like the plague. I was one of those developers to some extent. In 2021, you would still find me firing up Visual Studio 2015 to work on an older project.

But eventually, I started to see the toll of becoming stagnant as new terminology started to appear in front of me without me having a single clue as to what it was referring to.

Staying up to date as much as you can will make it much easier to jump on any project without a steep learning curve.

3. Personal Projects

While most of my technical coding experience has come from years working in the corporate world, a fair amount is also thanks in part to my own personal projects, such as this blog.

If you work for an organization or even if you attend a University and study Computer Science, you are limited in what you will do and in what you will learn while you are there. Most companies probably aren't okay with you coming in a Monday morning and deleting half of their codebase in order to implement a brand new library that you just read about. But maybe it's a good library. But that isn't the time and place.

When building your own projects however, you have that freedom to essentially use any framework and any library that you wish. It is your place to experiment with new technologies and if everything crashes and fails to compile, usually there is no harm done.

2. Professional Work

I hear alot of talk from people getting into web development and software engineering mainly for the chance of working for themselves and getting some level of financial freedom. They want to work on the beaches of Mexico and make 6 figures with no bosses in sight. Not impossible, but definitely not the most ideal route to take if you are looking to advance your skills in any real meaningful way.

The truth is that setting up a simple personal website on a shared server is levels of magnitude different than working on a high-scale web app for a big company. Alot different.

For one, there's just alot more code to deal with. Typically code written by many other developers throughout the years. And this code is probably not easy to read.

Getting into a paying corporate job, even if just starting out, will put you at the forefront of programming. Not only will the work be more challenging, but you will be surrounded by more senior developers who can answer your questions in real time and who can suggest better ways to do things.

1. Old code

And lastly, one of the worst things that you can do (and that I have done) is to keep around your code way after it is no longer usable, or even worse, deprecated. But everyone does it as this can be considered an expensive task in terms of time and energy.

The biggest issue with this is that inevitably, the more that you maintain old and outdated standards, the more you tend to keep them around in your day to day coding life. That means that the next time you write a brand new component for a brand new system, you might find yourself using a technique that you first used over a decade ago.

That could mean less optimized code and more unsecure code as well. Just like your engine parts are designed to eventually need replacing, so too does your code.

Learning to code is inherently not a simple task. Like with anything else in life, you have to sit down, buckle up and then do the work.