How do I land a six figure job in the coding / software business?

Be a rockstar developer (hint: It’s not as hard as it seems).

If a big salary sounds OK with you (it does to me), you may want to consider looking into the below set of top developer skills. They’ve worked for me. And they’ll work for you too.

Read on and enjoy!

Skill # 1 – Master your Text Editor

Text editors are your friend. Really. As a developer you should get to know them because you will use your favorite one again and again!

Probably the most popular one around is Visual Studio Code (VSC). It’s free. I use VSC often and love it! What makes it good?

  • It’s pretty light weight (opens fast)
  • Built in file explorer
  • Built in search that is actually awesome, fast and just works – it finds what you asked for!
  • Built in Git version control (more on that later)
  • Tons of useful plugins to make a developer’s life easier. You can even search and install those plugins right from within the editor – sweet!

Another popular text editor that’s helped me for decades now is “vi“. It’s something I typically like to use on the mac or linux command line (more on that in the next section). It doesn’t have a GUI but does allow me to make quick edits to files anywhere on my computer or even on remote computers.

I still use the basic Windows Notepad. Super light weight. Super fast. Good for copying and pasting without any formatting junk.

Notepad++ is another great, lightweight text editor with a little more power than just the Windows Notepad. It has syntax highlighting built in for many languages and this helps me to quickly look at code and understand it better.

And there are tons of other text editors to choose from.

Skill # 2 – Embrace the Command Line

The command line is a power tool for developers. It’s that scary looking black box you may have seen with a little blinking cursor. Like in that movie: TRON.

The command line only accepts text input and pretty much only produces text output. So there’s no GUI (graphical user interface).

However, the command line lets you do things you can’t do as easily or at all using the standard Windows or Mac/Linux GUI.

On Windows it’s known as the “Command Prompt” or “PowerShell”.

On a Max / Linux it’s known as the “Terminal”.

Having lots of power at your fingertips is very cool and sort of addicting when you get the hang of it.

For example, you could:

  • Scan a remote PC and see what vulnerabilities it might have
  • Log into a remote PC and make changes (with permission of course!)
  • Create, edit or remove any file or large numbers of files on your PC all at once
  • Search your PC (or a remote one) for a file containing some text
  • Automate common tasks through “shell” scripting

Skill # 3 – Build up your IDE

IDE = Integrated Development Environment. Examples of this include Visual Studio, Eclipse, PHP Storm, etc.

An IDE bring together the most common tools a developer would need to build software. Including text editing, debugging, building (compiling) and version control.

So instead of having multiple applications doing all those separate things consider using one tool which includes them all if you can. Or multiple is OK if that’s what you prefer!

If you’re like me, Visual Studio Code might be your IDE. It depends on what type of coding you do. I also use Visual Studio for certain projects which has more tools available such as advanced debugging and the ability to build older versions of .NET code (which you can’t easily do on Visual Studio Code).

Skill # 4 – Debugging

Debugging is a mindset that you have access to tools and resources to help you troubleshoot and fix problems with your code both before and while you are running the code.

I’ve done a little web development in my time and I like using the browser, specifically Chrome’s and FireFox’s developer tools (right click -> inspect), as a way to debug web apps.

If it’s something I can’t see in the browser it typically requires I view logs on the server side or my local PC file system.

Often I use Azure’s app insights for apps I work with that are build in Azure.

I also often look at stackoverflow too. They always seem to bubble up in my Google searches for errors I run into.

Skill # 5 – Manage code changes with Version Control and Git

Using Git is a must for just about any developer. Understanding version control IS a must for any developer. Period.

Why? Because as a developer you will likely work with other developers. And they may need to read, adjust and approve your code. Or vice versa.

And using version control is key to managing changes to your code.

Version control software, including Git, allows you to work on and save multiple features of the same application in parallel. This is called “branching”, where each feature of your application might have its own branch. And each branch can be independent of other branches. Meaning one branch’s code can be different from another branch’s code. On the other hand, a particular branch can be “merged” into another branch to bring two changes into one (brining a feature into the application).

Skill # 6 – Setup CI/CD Pipelines and be happy you did

Setting up build and release pipelines is great for automating the build and release of your code. So you don’t have to manually move code changes from your local PC to the cloud (dev, test, production servers, etc).

This turns out to be incredibly useful especially when the project you work on requires changes often and there is a need to send those changes to different environments for different stakeholders to test.

The “CI” part of CI/CD is the continuous integration, meaning the auto-building of your code. You write code locally, test it there. Then push it to your central repo in the cloud. Where that triggers a build (done by your build pipeline you setup ahead of time).

The “CD” part of CI/CD is the continuous delivery, meaning the auto-release of built code into a dev, test or production environment. So as soon as a build is finished building, your release pipeline (you setup ahead of time) grabs the new build and send it to a location where it needs to go.

Once you’ve setup your CI/CD pipeline(s), the speed at which changes are deployed to the right places makes you look good. Trust me 🙂

Skill # 7 – Apply DevOps into your work

Related to CI/CD above but not the same, DevOps is a cultural belief that software development (that’s the “Dev” part) should integrate with the operations or release and maintenance of that software (the “Ops” part) with the goal to build better software in less time.

It means, if software gets coded up it also needs to be regularly built (compiled), tested, released, monitored and adjusted. As more code is changed, we need to again do those same activities. And the process just repeats.

All these DevOps activities aim to generate software faster and with higher quality.

Meaning we setup automation in the build and release activities. So as code is written and committed, the code is auto-built and auto-released to a location a tester can test. A tester could approve and someone on the operations team could then send the build to production. The operations people can then also monitor and react to any issues and recommend adjustments to the developer team.

I’ve used Azure DevOps (it’s a software tool) since 2016 (when it was called Visual Studio Team Services). It’s amazing. The integration is amazing. I highly recommend it to implement the DevOps concept.

With Azure DevOps you can:

  • Write requirements (user stories, and see how those changed over time)
  • Store code in repos (and tie committed code to user stories)
  • Manage pull requests (that’s you reviewing/approving someone else’s code or vise versa)
  • Setup build and release pipelines (can be kicked off by pushing code from your local computer) to dev, test and production environments in Azure cloud, AWS cloud or really ANY cloud service
  • Create and run test cases
  • Auto-export requirements, test cases and their results. And tie them all together using what is called a trace matrix (I use Modern Requirements plugin for that). That’s great for making regulatory or “QA” folks happy, especially in regulated industries like healthcare, automotive and aerospace, etc.

Skill # 8 – Know about the amazing Cloud tools at your disposal

You don’t need to be an expert in all the major cloud providers (AWS, Azure, Google, etc.). But you should know about the major, common tools available from those providers.

They are (examples in parenthesis):

  • Compute (web/app servers, serverless functions, AI & Machine learning)
  • Content Delivery (CDN)
  • Storage (Amazon’s S3, Azure’s Blob storage)
  • Networking (web app firewalls, traffic routing)
  • Automation (e.g. Azure’s Logic apps, Amazon Simple Workflow Service)

One example is I took advantage of using Azure’s CDN service to host a statically built website (I used Hugo as the static site generator) which allowed the website to scale without me worrying about traffic slowing down the site. Before starting the project I was thinking about using WordPress but that would have required setting up a web server and a database server and then I’d have to manage those as traffic scaled up. With the CDN approach I could focus on building something great, letting the CDN to all the hard work and think less about the infrastructure worries. Awesome!

Skill # 9 – Understand Virtualization and Container concepts

Virtualization enables you to run one or more full operating systems on a single PC. This is great because you could setup and run just about any OS on your PC regardless of what OS natively runs on your PC.

Containerization is also key. Docker is all the rage and for good reason. Docker is a containerization technology which means it virtualizes “workloads” instead of virtualizing an entire OS.

A workload is just an application and the things / libraries / infrastructure the app depends on (an OS does NOT need to be part of the workload). All packaged together into an “image” that can be run as a “container”. So, you can setup and run just about ANY technology on any computer without also needing to run the OS those things were designed for. Nice!

And it turns out virtualizing a workload is much faster than virtualizing an OS because there is less overhead with the former.

For example, with Docker I can package together a web server as an “image”, a database server as another “image”, and then run those images each as separate “containers” running independent of each other. But still able to communicate with each other. And I also do NOT need to install any OS to support those containers other than just have Docker running on my PC.

This means containers boot up faster (almost instantly in many cases) vs many seconds or minutes with a full OS. And now you can start to see why containers are very cool!

Skill # 10 – Build better software by being Agile (talk with people)

Agile is another cultural belief that says good software is built by putting more value on interactions between people vs relying on tools, processes, documentation, contract negotiations and planning.

There is still value on those latter things, just more weight goes to the former.

Specifically the Agile Manifesto states:

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

In other words, while there is value in the items on the right, Agile values the items on the left more.

The key here is, as a developer, you don’t want to simply take orders and just write code to the specs someone hands to you. Instead, listen to what others are saying to you and offer your feedback, collaborate, do what you think is right to achieve working software. The original spec might be OK but in case it turns out not to be you’ll be glad you had the conversation.

Honestly, people are not great at asking for things they need, mostly because they don’t know what they need. They don’t always know what is possible.

Having these kinds of conversations upfront before code is written will make your life a lot easier. As a result you will more likely end up with the “right” thing to build AND that makes you look like a rockstar!

Skill # 11 – Test to requirements, often and in the appropriate location

Testing to me means looking at the requirements and figuring out if the code written meets those requirements (I call this verification). I like to write code in small portions and test those right away. Then move on the next portion. That way I have confidence thing works as I go. And I don’t need to do a big, long test at the end.

Testing can also mean did we build the right requirements (I call this validation). Hopefully you collaborated with stakeholders upfront so you have confidence what’s being coded is the right feature.

Verification and Validation are two important but very different testing concepts to be aware of.

Also, what I’ve found critical is after you write your code you do want to test your code in the environment you expect a stakeholder to test it in. Otherwise you run the risk them pointing out to you: “hey, it doesn’t work” and that is embarrassing as hell. “But it worked on my machine” is not acceptable to anyone. Even if they don’t outright say that.

You should expect a tester will find some things in your work that are broken or needs adjustment. But don’t expect anyone to be OK with what you wrote just flat out not working.

And when I work with other developers and they want me to test their work, I expect they at least test what they did works and in the location they want me to test it. Expect others to expect the same of you.

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes:

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>