5 things I've learned in my first year at Plain

My passion for software development sparked during my time at university. At the time I was studying a subject that I had little interest in and didn’t nurture my creativity and curiosity. During the summer of my second year, I decided to teach myself how to code and quickly discovered that coding would allow me the freedom to be creative, give me the knowledge to solve problems, and the skills to build anything that came to mind.

Software Engineering is a constantly evolving field, so learning and improving your craft is a career-long endeavour. Since the summer I dropped out of university to pursue a career in software development, I finished my apprenticeship degree in Digital Innovation and now I am a full-time Software Engineer at Plain. In that time I’ve learned an incredible amount. I still have a ways to go and I aim to become incredibly knowledgeable in the field.

I’ve spoken to some of the engineers I work with and also conducted some of my own research. Here are 5 things I’ve learned that, if mastered, can make you a better software engineer.

Focus on the fundamentals

“Why do you think I’m the best player in the world? Because I never ever get bored with the basics.” - Kobe Bryant.

When I first started out I was amazed by just how much there was to learn and at the speed which things changed. Engineers constantly create new tools, frameworks and methodologies to help them work more efficiently and reliably. Staying up to date requires quickly learning new languages and frameworks, and a decent amount of fundamental software knowledge.

HTML, CSS, & Javascript have been around since the very beginning of the web. Over the years these languages and technologies have evolved. However, the underlying core concepts remain the same. The fundamentals are essential, mastering them will grant you the knowledge and experience to transfer your skills across languages and frameworks. Once you’ve mastered the fundamentals, you can layer more advanced and complex concepts on top. Advanced concepts are far more accessible when you have a clear understanding of how all the individual pieces work and fit together.

Building blocks sitting on a laptop

That said, becoming a true professional isn’t just about learning all the frameworks and languages. At its core, it’s about solving problems. These languages, frameworks and libraries are just tools to help solve the problem.

There are lots of tutorials on Udemy and YouTube to study. One of my favourites that I often refer back to is the CS50 course delivered by Harvard. The lectures are designed for beginners and explain fundamental concepts such as arrays and different sorting algorithms in a well structured and easily digestible way.

Reading code

When joining an existing project, you can’t start contributing until you’ve oriented yourself within the codebase. Reading code is a skill required to learn and collaborate with fellow engineers during pairing sessions or code reviews.

Software engineering isn’t primarily about writing code, far more time is taken up by reading, reviewing, debugging and understanding code. Often engineers work in teams with a large codebase, and being able to understand and navigate around the codebase is important. It allows you to identify patterns, familiarise yourself with common solutions and master the approaches of more experienced engineers.

Here at Plain we often participate in code reviews. Code reviews are essential to maintaining high quality code as well as the perfect opportunity to practice and improve your code reading skills.

However, unfamiliar code can become confusing very quickly. It’s easy to get lost and realise you’ve wasted hours and still don’t quite understand what the code is doing. When you’re stuck, simply give yourself a specified amount of time to try to understand the code and find the solution. Although being lost in the code isn’t always a bad thing — it allows you to get comfortable with being frustrated and learn that it’s possible to come out the other side.

Patience & asking for help

Learning when to ask for help is an important skill to hone. Struggling with a problem for a long period isn’t beneficial to anyone. Often when I find myself struggling I ask one of my colleagues to jump on a quick call and pair with me. Usually, explaining the issue to someone can really help you understand the problem better.

Pair programming is an agile software development technique where two engineers work together on one machine. During my time here at Plain, I’ve paired on a variety of different tickets, allowing me the opportunity to understand our entire code base and experience working in an area I'm not familiar with.

five men gathered around one computer

Most recently I've been working on our new documentation site where we reference our API’s GraphQL Schema. So I needed to write a script to dynamically fetch the schema from our backend, to ensure our docs would always be up to date. This required some work on our backend, specifically our Lambdas. This is an area of the product I had no prior experience with, so I paired with a fellow engineer and had the opportunity to gain a deeper understanding of how Lambdas work and how we build them here at Plain.

Pairing with senior engineers provides the perfect opportunity to ask questions, learn new techniques, and fail in a safe environment. Since I joined the team, my confidence has massively increased and I feel far more comfortable pairing with my colleagues and even suggesting solutions.

I find the best time to pair is when you’re working on an area of the product you’re unfamiliar with. You can begin by asking a colleague to scope out the tickets with you and pair on the first few. Code reviews are also a great way to incorporate quick pairing sessions. Instead of discussing comments on the pull request, jump on a call to discuss the issues and comments.

Side projects

I am a visual learner, so I find tutorials incredibly effective — they’re a great introduction to complex topics. However, tutorials are limited when it comes to practical implementation. If you work on your own side project, then there is a sense of freedom. You have the opportunity to choose your tech stack and develop a deep understanding of a certain language, framework or theoretical concept.

Often working on a product in a team means being exposed to a small portion of the product. However, when creating your project from scratch you’re exposed to the entire software development life cycle. This allows you to work in areas such as design, testing, and deployment. Side projects help you learn new skills through deliberate practice, whilst simultaneously improving your current skill set.

Often the perfect side project is solving a common problem you have. As a muslim, I pray 5 times a day, and throughout the workday, it can become easy to forget. So I decided to build a chrome extension that would display the prayer times for each day and highlight the current prayer for me, reminding me of the prayer times throughout the day. If you’re struggling to find some ideas, here are a few more I’ve done in the past:

  • Chrome extension rotating through your favourite quotes
  • Pong game
  • Multiple choice quiz
  • Your personal website

Getting business context

Becoming a better software engineer is largely about becoming a well-rounded engineer. Senior engineers have a broad understanding of the problem they're trying to solve and understand that there are business requirements that demand you go beyond just writing functional code and checking off tickets in the backlog. This understanding of the user, their constraints, and the needs of the business allow skilled engineers to make smarter and more effective decisions about how to solve problems.

Working closely with the product team will build your understanding of what the company is prioritising. Participating in customer research, communicating with customers and working with the design team will broaden your understanding of customer requirements, how you solve their issues and meet their needs. This will allow you to gain context and understanding about the decisions that are made and how they'll impact the product, the users and the business as a whole. This is what separates the Juniors from the Seniors.

In conclusion, practising and eventually mastering the topics we mentioned in this post will put you on the right track to becoming a better engineer. Mastering the fundamentals will help you learn the complex concepts faster and with a deeper understanding. Reading code will allow you to identify patterns, familiarise yourself with common solutions and learn the approaches of more experienced engineers. Asking questions and pairing with your colleagues will be the perfect opportunity to share knowledge, broaden your skills and improve your communication. Your side project will allow you the freedom to be innovative, experimental and build whatever your heart desires. Finally understanding the business requirements and user constraints will result in you making more effective decisions about how to solve problems.

  • #blog

Plain is now in open beta ✨

Sign up now and provide support that's as polished as your product.

Join us 👩‍💻

…and write the next post. We're growing our small but mighty team.

© Plain. CS without the BS since 2020.
plain.com