Programming is a superpower. You really should learn it. It allows you to create anything that you can imagine.
To help and encourage people to get started, I’ve written a brief overview of what I view as the fundamental “pillars” of being an effective software developer.
The skills needed to contribute to software development are broad, but fall into four main categories. Each of these categories are useful independently of the others, but together they constitute the essence of contributing as a software developer.
They can be pursued in any order and have considerable overlap, but are described separately here just to provide logical divisions for the purpose of discussion.
Increasing proficiency in any of these categories can help improve performance in the others. For example,
- learning a lot about executing software can help you understand how to better test the code you write.
- reading code can help you understand how other programmers solved problems that you’re faced with, informing your approach.
- testing code helps you understand why unit tests are important, and motivates you to write code that’s easy to test.
The first step to being able to write software is to be able to execute software.
If you were able to navigate to this page, then you’re off to a great start!
You will of course be using software to help you write software, and other software to run the software you write. It’s software all the way down.
Not to be underestimated, the execution of software is a skill with a lot of depth. Studying the environment in which your code executes will allow you to have more control of the way your software runs, help inform design decisions while writing it, and defines the interface that you will implement for its use.
Software development is like many skills in that it is principally learned through the observation of others. Reading code written by others is vital to becoming conversant with a programming language.
However, reading code is not just useful in learning how to program. It is a useful skill that is relied upon constantly even by experienced developers. A big part of most developers time is spent reading and understanding code they didn’t write:
- Any time a change to software needs to be made, the surrounding code must be carefully studied.
- When teammates make code changes, those changes need to be reviewed by other programmers in order to be sure they function correctly. Software is developed in communities, and doing great code review is an important part of contributing in these communities.
- In order to reuse code (that is, libraries) written by others, you have to learn a little bit about how their code works. If you’re having trouble using their code, looking under the hood at how it is written is a useful way to quickly understand the problem.
Obviously, writing code is an important part of software development!
The neat thing when starting out is that it doesn’t matter what you write.
You can pick any topic you want, and just start programming about it! If you can’t think of something to write a program about, or if you don’t know how to write code yet, you can start by copying simple programs in programming tutorials. This is writing code.
You will make mistakes, run into problems, and hopefully solve some of them. You will learn to struggle against your mind’s limits and find clever ways to avoid them.
Eventually, you’ll get used to the details of programming languages and begin to think in terms of code organization, performance, and other second-order challenges.
Once (or maybe a bit before) you are conversant with writing clean, understandable, testable, performant code, you will probably write some software that will have users! At this point, you will have to focus on how to get feedback from users in order to increase the usefulness of your program.
Software gets really complicated. It’s almost a given that any software project that has many changes over time will become challenging to understand. It’s not possible to avoid making mistakes when attempting to make some change, so a big part of software development is testing everything.
- Functional tests - you run the program and directly verify its behavior.
- Unit tests - these are small pieces of code that test other parts of code.
- Integration tests - you run the program together with other programs to be sure they work correctly together.
Helping with functional tests is a great way to contribute to software development if you’re just getting started. It will help you understand how software changes, and expose you to important parts of the software development lifecycle.
You can find some software that’s being actively developed that you know how to use. Look up some changes that are being proposed to it, and try verifying the change. This can be really easy or really difficult depending on the software, but it is an important skillset within the context of being a dev.
Updated: 19 December, 2021
Created: 28 November, 2021