Software Engineers are problem solvers

Work like a professional

Coding is a very accessible activity, and that’s a great attribute about programming. With a little bit of knowledge and a few lines of code you can build a simple app or a basic web page. There are tons of resources and tutorials that can guide anyone with an interest in software development through the early stages of exploration.

There is, however, a huge gap between the kind of step-by-step “happy path” tutorials aimed at complete beginners and the complex engineering problems you’ll be expected to solve as a professional. To become a professional software engineer, you have to recognize that gap. You also have to develop the attitudes and behaviors required to bridge it.

Code with intention

Hacking together pieces of code and just trying things to see if they work is a behavior often seen in hobbyist programmers or beginners in the “explore phase” of learning. To become a professional software engineer, you need to graduate from the “hack and slash” mentality.

Code with intention, and take a deliberate and considered approach your work.

The following actions and behaviors will help you do that:

• Planning out your solution to a problem
• Considering the trade-offs of different solutions
• Accurately implementing your chosen solution
• Understanding the purpose of each line of code

Coding with intention becomes easier if you have a consistent approach to problem solving. We’ll look at that next.

Develop a solid problem solving approach

Being a good software engineer isn’t about memorizing a bunch of syntax and functions and then magically typing out a bunch of code that just works. It’s about solving problems. Programming languages, frameworks, and libraries are just tools you use to help solve the problem.

Problem solving is hard. To help you out you need a well-practiced, consistent approach.

Work on developing a solid approach to solving problems. You’ll then be able to tackle any problem by breaking it down and solving it logically and systematically.

A good problem solving approach includes things like:

• Clearly understanding and/or defining the problem
• Breaking down large problems into smaller problems
• Solving the problem at an abstract level first
• Using notes and pseudo-code
• Running code early and often

This is something we focus on a lot in our program. To get a taste of the kind of things we talk about, check out this article.

Learn to love debugging

Debugging is a key skill for any programmer or software engineer. However skilled a programmer you are and however good your problem solving approach, you’re going to encounter bugs. Don’t worry about this, it’s a perfectly normal occurrence. A lot of novice developers have an irrational fear of debugging and get anxious if their code doesn’t work correctly straight away. This is because they see bugs as getting in the way of their coding. That’s the wrong way to look at it.

Don’t treat debugging as a chore, treat it as an opportunity.

Think about bugs and debugging in this way:

• Bugs can help you solve problems. Your high-level solution to a problem may seem good, but once you start coding you might discover logical errors or edge cases you hadn’t considered; this can make you revisit your assumptions and rethink your solution.
• You can learn from fixing bugs. Debugging can present you with unfamiliar methods or functions or aspects of a framework or library that you hadn’t encountered before.
• Debugging familiarizes you with a codebase. Fixing a bug can force you to dig into the codebase to understand the underlying logic of a program.
• Debugging is part of the software development process. Software is constantly evolving and improving; finding and fixing bugs helps drive that improvement.

Learn to use documentation

When learning a new language, tool, or framework, don’t spend lots of time trying to memorize every single method or function, or an entire API. Instead familiarize yourself with the documentation for that language or tool.

Learn to read and use technical documentation. Combine this ability with strong mental models about fundamental programing concepts, and you’ll be able to quickly pick up new tools and languages.

The combination of the two things is key. For example, if you have a solid understanding of how a combustion engine works and know how to read engine schematics, you can use those two things together to quickly start working with any engine.
If instead you’ve memorized every single piece of one particular type of engine, but without those other skills, then you’re limited to only working with that type of engine.

The best developers and engineers don’t necessarily know the answers to everything, what they do know is the underlying context for those answers and how to find the specific details when they need them. Don’t aim to become a ‘React developer’ or a ‘Rails developer’, aim to become a software engineer who can quickly adapt to work with any language, tool, or framework.

Don’t get attached to your code

A common beginner trait is to view code in a reverential way as some sort of artistic creation, and having a desire to write some “perfect” code and then not change it. Avoid this kind of behavior. Professional software engineers see code as a solution to a problem; it’s a means to an end rather than an end in itself.

Don’t get overly attached to, or egotistical about, your code. Be prepared to rethink, refactor, or even replace it entirely.

A big part of this is being able to accept feedback and criticism. The purpose of that feedback is to help you improve your code; don’t take it personally. Remember that you are not your code, and a criticism of or feedback about your code isn’t a value judgment about you as a person.

Also remember that as a professional your code won’t be your code. The code you’ll be working on won’t be for some personal pet project, but a collective undertaking with a specific, shared objective. Thinking of parts of a codebase in terms of individual ownership is problematic in a professional environment.

Summing it Up

In this article we’ve examined the difference between how hobbyist programmers and professional software engineers approach working with code. If you really want to launch a long-lasting career as a professional software engineer then you need to adopt these professional attitudes and behaviors. Let’s recap on what they are:

• Code with intention, taking a deliberate and considered approach your work
• Develop a systematic and logical approach to solving problems
• Don’t treat debugging as a chore. Accept it as a normal part of software development and use the opportunities it presents
• Learn how to read technical documentation, and combine this with strong mental models to quickly pick up new languages and frameworks
• Don’t get attached to your code. Treat it as a practical solution to a problem, not an artistic creation

If you want to be a professional software engineer, you need a professional approach to solving problems with code. When you combine this with a well-defined path focused on fundamentals, solid study habits, and good communication, you’re well on your way to achieving your goal.