How I learn hard software engineering concepts

At Upwork, my role as a backend platform software architect requires learning new programming languages, development tools, design patterns, and software architectures.

Learning something new and complicated impacts all of us. Whether changing jobs, learning a new hobby, having your first baby, or learning a new software stack, we often have to learn a new skill. It’s never easy; we tend to learn by doing it on our own.

My sons went through this recently. One son was taking a Practical Engineering course where he struggled to learn wood cutting, hot glue guns, and Arduino programming. My other son started a summer internship and was under the gun to learn a new CAD software package while researching how a temperature probe works.

There are a few strategies I use to learn hard things. While these lessons learned are primarily with software development, I believe they apply to other situations you may face.

Compounding factors to consider

Some key contributing factors can make learning technical topics even more complex. In the case of software apps that have been updated for over twenty years, simple tasks can become complicated. If you poll Excel or Photoshop users, they’ll tell you they only use about five percent of an app’s capabilities.

The overwhelming trend is that product managers and designers focus more on capability than simplicity. To justify that focus, be prepared to hear complicated functional models that may appear counter-intuitive. These models may be based on centuries-old concepts like typesetting (typography) or two-week-old fads (like blockchain).

Your organization may be accumulating technical debt (implementing a solution that attempts to save time and money in the short term but requires more fixes in the long term) and loss of talent due to the “great resignation.” The result is that critical decisions in product design may be lost if not thoroughly documented. Learning technical topics became more cumbersome with the recent migration to isolated virtual workforces due to the COVID pandemic. 

Help strategies you can use today

Learning hard things requires a more strategic approach that I have grouped into categories starting with recommendations for building great software and ending with personal traits.

Learning how to build great software

1. Think simply: A good design should not be ridiculously complicated.
2. Start small and iterate: Find an equivalent “hello world” example. This is a popular software programming pattern where you start by doing the simplest possible thing (like displaying “Hello world”). If your organization or tech stack doesn’t have a clean version of this yet (ex: a full microservice with simple interface with health check), offer to build it, document it, and own it.
3. Learn from others: Take a couple of tutorials to learn the fundamental concepts (like building “hello world”) before you start. It appears that just about everything you’ll want to learn is on YouTube.
4. Take advantage of “chunking”: Break a complex problem into smaller, simpler pieces. Verify the components and pieces are correct with unit tests. Layer in the complexity as you go and always test along the way.
5. Allocate time to experiment: Take notes of what works and what doesn’t. You might have a different note for each day or each component you build. These notes help you remember, and they should always be searchable. If you or your team gets stuck, you can search for similar situations.

Learn from your mistakes

1. Taking advantage of failure: Save your successful tests and failed attempts. Once you create something useful that works, save a copy. You might have several variations, and a commitment to quality shows concrete progress for yourself and your team.
2. Retreat to a known base: When you experiment and fail, go back to a known-working version and try something else. Eventually you’ll learn what works (and what doesn’t).

Collaborate with your team

1. Does anybody write things down anymore? Essentially everything in the world is documented online these days. Whether in a knowledge base or GitHub, reduce the need to relearn what you did later by documenting your work.
2. Tracking outlier situations: Error conditions happen. Record every obscure error message and error scenario. When you encounter issues that don’t make sense, look to see who else has seen this. Becoming resourceful with creative workarounds is critical to the learning process.
3. Rely on a subject matter expert (SME): If you have an expert available, collect questions, and schedule a “sync-up” to review at least once a week.
4. Handling an issue with a tool or app: Where possible, always use a vendor’s technical support or its active online community of users. Even though support can be slow to respond, continue to attempt to resolve the issue. A complete description and evidence will help you (and the vendor) better understand the problem and save time.
5. Taking advantage of a worldwide, open-source community: With active communities like StackOverflow, Reddit, or the actual contributor, people are more than happy to offer advice to your technical problem. This assumes that you’ve done the research and documented the issue.
6. Make milestone attainment count: After you and your team complete a challenging project, milestone, or deliverable, record lessons learned, perhaps as a “how-to” document or video. Make this a team effort.

Personal fine-tuning

1. It’s not you: Don’t blame yourself if you don’t have all of the answers. Nobody said that learning was going to be easy.
2. Take breaks: If you feel frustrated, stand up, and come back after lunch (or even tomorrow). Jot down progress notes, issues to research, and lessons learned.
3. Balance how long you struggle: If you can’t figure out a problem within ten minutes, don’t panic or give up. But if it’s been more than a day or two without progress being made, schedule a 15-minute live sync-up with a colleague or expert.
4. Teaching helps understanding: Explaining the problem (or presenting a technical topic) to someone else can make a possible solution reveal itself. Alternatively, recording a Loom video using your laptop’s webcam can be used for someone else to view.
5. Celebrate: Finally, celebrate progress with a meal out with friends, a new geek toy, clothes, or whatever makes you happy.

Being open to always learning—especially with hard things—is critical for all of us to improve in our craft. Good luck!