How to become a better programmer

I'll be the first to admit, programming was never something I found easy. My very first experience in programming was when I got this book at the ripe age of 11. I liked playing my Nintendo 64 and wanted to make games on my own.

The book that changed it all for me

My ability was far under sub-par. Somewhere in these forums I wrote a post asking for help trying to understand a while loop - needless to say I got defensive because I felt I was being talked down by people smarter than me, telling me that I should start and learn more simpler things first (than dive right into making a PC game).

Forums did actually look like this (circa 2005)

The truth was, I was being too ambitious. BUT - TwisterMan was not going to code itself! (All drawn in glorious Microsoft Paint :)).

Animation frames of TwisterMan doing some whirlwind attack

Watch out for spikeo!

*rawr*

And whoever this boss was called...

Baaaa?

The point I'm trying to get across is, I was bad at programming (and not that good at design either - ha!). I didn't know how to think like a programmer, and I was also struggling to learn because I did not have any fundamentals down. Fourteen years later, I got a bit better at coding. What changed? Does this mean it takes you 14 years to become a good better programmer? Will everyone start out their programming careers drawing spikeo?

I'm going to share with you specific things that have helped me progress my ability as a programmer and the different stages I think everyone falls into as they get better.

As a beginner

Stop thinking you are good

Humble yourself. The worst enemy you have against you becoming a better programmer is yourself. Besides, being humble is a step to becoming happier, so why won't you try?

You are going to be stubborn and not listen to me, even if you say you will try. Pride is the hardest for us to stop.

Learn the fundamentals

Pay attention to the fundamentals when you begin, do not worry about anything other than understanding the basics. Do not even try to visualize your program. The best thing you can do when beginning is to learn to understand to follow the logic.

Understand that if something is true in an if statement, then the code inside the if statement will be ran. Understand how many times a for loop is executed. Understand what curly brackets are used for. Understand different [primitive] data types. Etc.

Stop worrying about the algorithms

I really dislike purely algorithmic-based questions. I don't feel that these questions help you quantify yourself to a programmer who has experience - this [hiring] company feels the same way. To be honest, I'm not that good at following some mathematical programming algorithms, and I'm not that good at logic puzzles either! 

You will either love algorithms, or be indifferent to them, don't worry too much about what side you fall on. What's more important is that you have some ability to problem-solve.

Get some grit

Seriously. This is true even outside of being a programmer, if you don't have the capacity to keep on trying when you fail, you will struggle. If you don't have grit while programming, you will struggle more. I attribute nothing more to my success than my grit.

The face of True Grit

No, grit doesn't just come easily. You can't buy grit. You have to earn it, grow it, strengthen it. You need a goal to foster grit; without a goal, you won't have any reason to keep on going.

What is my goal, how did I get my grit? Ironically, it came from my pride. I am stubborn, and only pursued programming because it was hard, and could not live knowing the fact that something was too hard for me to understand. I came to try harder because I didn't want to be not smart enough to understand.

Only through conflict do we evolve

Create a small project

It doesn't have to be large, create something that interests you [or is useful in some way]. Stretch and try something you haven't done. One of the first applications I made was a console application that took in input such as an author's first and last name, as well as their published work to format the works cited page in the MLA style.

The whole application was about 70 lines long, and consisted of code that got the user's input (akin to ReadLine in C#) and then outputted it in the right format. Just a simple console application.

As a novice

At this stage, you'll be able to write some code but unable to write anything of substantial value. You'll understand different types and know a few different terms, but most of your experience with programming is likely with a single language in a single editor. You are also probably okay at coding simple exercises, but only if they are explained to you.

Look at other people's code

Most of my time as a novice was in college, where I heavily learned from your soon-to-be favorite website, StackOverflow. Look. Read. Pay attention to how people code. It's not any understatement that this website helps you earn your degree.

Sponsoring candidates since 2008

The further along you get in your experience, the more and more you'll end up on StackOverflow.

For those who haven't heard of StackOverflow, StackOverflow is a community Q&A programming resource. People have programming questions that they post, and the community can answer them. Good answers get up-voted, while poorer-quality answers don't. You will see both good and bad code on StackOverflow (and occasionally funny ones too). Don't get too attached to memorizing how to write perfect code, but pay attention to patterns as you frequent yourself on the site.

Learn OOP

I would estimate that most developers will have to work in object-oriented systems, so it is critical to understand what OOP is. In a nutshell, OOP organizes your programs as relationships and logic that is applied to objects. Objects typically reflect the domain you are working with. I'd first go here to learn what OOP is.

Take the hard classes

This only applies if you are in school, but if you are not in school - learn the algorithms online. You can't avoid it, you'll need to at least once learn data structures and algorithms (the heap, stack, queues/linked lists, pointers, etc).

As long as you can pass the hard class (without barely scraping by), you should be ready for continuing your programming knowledge. I'd recommend at least a B, or B+ (or however your online class grades you).

At least half of the people can't make it through this class/concepts. This class truly weeds out those who aren't capable of progressing further (which is why grit is so important!!) Wishing you luck.

Expand again

Take on another project of something that's larger than an older project you've worked on. Appropriate-leveled projects are web applications, hardware projects, contributing to open source libraries (if you feel up for a challenge), or maybe a desktop application.

The project you work on here is likely going to land you an internship (or give you relevant experience to apply for a position), so if you have a rough idea of something you are interested in, try building a project in that same domain.

If this seems too hard, good. It is supposed to be challenging. Working on projects like this really help propel you and help teach you a lot that transfers directly into what you'll likely be doing for your programming job.

Give back

You are capable enough at this stage to tutor, or mentor younger programmers. Take the opportunity if you are given a chance. Teaching helps you learn. You might consider join and volunteer for the hour of code. Consider tutoring? How about writing a blog? You can always consider giving back at any later stage of your career too!

As an entry-level programmer

You will have some experience of coding, but not much (if any) real-world programmer experience at this stage.

Question yourself

Do you really enjoy programming? Is this something I see myself doing for many years? You might not know exactly what you will be doing, but if you enjoy learning new technologies, growing and problem solving, then you are likely in the right field.

Don't be afraid to back out. If you don't like being a programmer, be honest with yourself and look to pursue a different path that better fits your interests.

Reviewing your strengths and weaknesses

Create a target for yourself

On the opposite side, if you do like programming, where do you see yourself going? Into web development, embedded systems, IoT, software development? You don't have to be fully committed in a particular path, but take steps in that path to consider if you want to pursue it further. Online classes or certifications can help you discern.

Expose yourself to different domains and find one that is interesting to you. 

Specialize

Hone in on languages, become a master of them - don't try to master it all. Ask if you can take a specialized role (if available) at your work. If you are freelancing, clients appreciate (and expect) you are a domain expert as opposed to a generalist.

An example of specializing is easy to visualize in web development. Focus on the front-end (js or react or etc.), or focus on the back-end (c# or php or node or etc.).

Generalize

Expose yourself to more than one language. A great example is if you work in web development. Expose yourself to CSS, JS and HTML. The same goes if you are in software development. The more you put your eyes on, the more you will learn.

Use source control

Get familiar with it, and continually use it as much as you can. You will be required to use source control in most companies you work for (unless I suppose you work at a bank).

Branching in Git

The bank reference is a joke, seriously. Learn source control.

Learn when to ask questions

It's learned on the job, but it helps to hear it before you get in.

As a mid-level programmer

Read read read

Read blogs, news articles, podcasts, videos on programming, technologies, and languages you are using. Subscribe to blogs or email newsletters. Here is a good page with resources for C#. You should also be doing this too. The more information you can understand about a language and the world (and how both are so interconnected), the better you will become as a programmer. 

This point is a set-up for becoming a better programmer at higher abilities, so be sure to practice this one regularly!

Discover the tools

Discover tools like CI/CD (Jenkins, Visual Studio team services) and build automation. Self-creating API documentation. IDE extensions. Assembly decompilers. Managing virtual machines. Different flavors of package managers (Chocolatey and npm). Kanban boards.

These are just some of the major players (and a bit of my own personal bias on tools that I use) when it comes to tooling. No doubt when you read this, there will be new contenders (and some will have gone away).

Go to conferences

Typically, you can get work to pay for these. Conferences give you a larger view of the technology field as a whole, and great insights from the people who are creating the tools and software you use on a day-to-day basis. There are very smart people who organize and lead talks that you can listen in on, and is a great way to humble yourself in a room of very smart people.

VSLive is a great conference for Windows/C# developers

More side projects

Continue to explore your interests in your Github. Try to create anything you find interesting, don't feel limited to what might make you money. Create something you find enjoyment doing! An easy few questions you can ask to help get you started:

1. What is a problem I'd like to solve?
2. What do I want to understand (that I don't understand now)?

Leech information

From those smarter than you. Ask them questions. Ask them why they chose to do it that way. Ask them why they chose that framework. Ask them if you do not fully understand. Don't go overboard, though.

Learn your domain

By this point, I would hope that you found a domain that is semi-interesting to you. Whether that is ecommerce, or agriculture, fashion, manufacturing - it doesn't matter the domain itself, what matters more is you actively go out and learn the field you are working in. You will no longer be siloed in code, you will be using your knowledge of coding to apply and solve problems in a domain.

This is why it's so important to find somewhere you like to work!

Learn the acronyms/terms

SaaS. DRY. SRP. SOLID. PaaS. Blue/green. + all the others. Once you begin to learn these, begin to look at how these are applied and how you can apply them as you code.

Improve your working memory

I am fully convinced that you can only be a good programmer if have these things:

1. Ability to think logically
2. Hold a lot of information in your head at a given time

Obviously, you need to understand logic (the problem-solving kind), but if you can't hold a lot of information in your head then you won't be able to grasp the bigger (and more abstract) problems you encounter the better you get as a programmer.

We have a limited working memory, and unless we can somehow empty our mind, we quite literally won't have enough brainpower we need. To that end, I have one suggestion that has helped me immensely in giving my brain more space, hashtable memory.

Instead of remembering everything in every little detail, I instead remember where the information is stored.

Hashtable memory

I tend to like to write things down, and will write down my knowledge in some media (pen and paper, .docx, online blog, Confluence-like services). The next time I need to remember details about Powershell commandlets, I just know where I need to look instead of all of the information.

Learn the big players (PaaS, Iaas, Saas, etc)

At this stage in the game, you should learn who the big players are and what they do, but you don't necessarily need to be an expert in them. Three examples are AWS, GCP and Azure; it's very possible you will use any of these in your day-to-day work and frankly its where the industry is heading.

In situations where there is fear of using online platforms, or a conservative workplace, you still might have your services on-prem. On-prem might also be used when you are responsible for hyper-sensitive data (such as PCI or PHI).

Understanding databases

Both relational and unstructured are database structures you will want to understand (if not, at least have working experiences with one of the models). A bonus if you work with big data (hadoop).

As an advanced programmer

Master your framework

In order to take the next steps, you have to know your framework down cold. Read extensively in the blogs and articles on the internet, continue to talk and share this information with others. This blog is an essential for .NET framework knowledge (obviously).

This includes learning your keyboard shortcuts.

It is in this step that you could be architecting your solution (a sample of how you might be applying your knowledge).

Structuring your application solution

Pay [more] attention to security

It's at the point where you are an advanced programmer that you'll likely be given work, or working on, projects that require certain levels of securities and permissions. You should already know OAuth, OIDC, session or cookie-based authentication, JWT and perhaps some AD knowledge.

Security should be a cross-cutting concern that is present in all applications.

You should also have in the back of your mind how to keep API keys/etc that are in your application secure too. You can read here of many anti-patterns of storing application passwords.

Practice your people/project skills

Skills like communicating project status to your boss, identifying and managing roadblocks, organizing project scope and communicating to stakeholders or non-developers will likely happen and are necessary for you to have (you don't have to be perfect). You don't live or work in a bubble, even if you want to.

Communicating with my boss

The same goes if you are freelancing!

Ask for feedback

Hearing you are bad at something is not what we want to hear, but if you want to get better, you will have to ask for it. Ask your coworkers, your manager, the people that have seen your code. You don't have to ask for strict coding feedback either, you can also ask if there are things socially you could improve on too. Any improvement on yourself will feed back into your ability to code better.

Make your process faster

Supercharge your time by automating things with a shell. If you don't already work in an organized environment with established practices, take the opportunity upon yourself to create scripts for yourself (with shell scripts), or do it the right (but harder) way and build a process that works to deliver value for your team (devops).

Throw yourself into complexity

This goes hand in hand with improving your working memory. Throw yourself into harder and harder code. Continue to push your limits of understanding.

Study [micro] optimizations

You should spend some time learning optimizations. For C#, that includes exceptions, looping, string comparison, ascii, structs and more. Knowing how and when to implement these [micro] optimizations really begins to separate the average programmers from the great programmers.

While the above link is great, it does not include information on performance of boxing/unboxing, you'd be best to view that on this page.

As a senior programmer

Let it be known that I am not a senior programmer yet, but am fortunate enough to work with people smarter than me that imbue these characteristics.

Choose compromises

At this stage in your knowledge and ability, there is no clear wrong or right answer that requires any thought - you simply pick the right option. More often than not, you'll run into questions that have no clear right or wrong answer, and you'll have to choose the less-worse option. Take this example of a recent conversation I had with a coworker.

He was discussing the options of exposing the HttpContext in a .NET Core web application. The question was whether to pass in the HttpContext through constructor injection or to access the HttpContext through a factory. 

Passing the HttpContext through the constructor serves the code fine and well, but using a factory can provide additional benefits such as custom (wrapper) HttpContext classes and easier modifications (additions) in the future.

The HttpContext factory in question was to be created as an extension that the IServiceProvider would call to associate the dependency. Creating the factory in this way, would limit the hosts [webhosts] that could use the extension - as the web host would have to be aware and make use of IHttpContextAccessor. In other words, if the application switched hosts, the HttpContext factory might not work.

We [he] reasoned that the better option in this case is to create the HttpContext factory option because it is unlikely that the application host would ever change.

Become a SME

Become someone who knows it all. Consider going into research if you want to explore paths that haven't been trekked yet. 

Will you be a know it all in the end?