What to learn as a backend dev

In the past few weeks I’ve been collating a list of topics that I plan to explore on my path of becoming a better software engineer. I’m sharing this here in the hope that it will be useful for others as well. I believe that a solid understanding of most of these topics provides a strong base knowledge. I’m going to use this as a guide, and I’ll be updating this post on occasion.

Note

  • this is a purely a technical list, and doesn’t include any other aspects of becoming a good engineer, which are plentiful and just as important: communication, conflict handling, domain knowledge, prioritisation skills, social skills, and many others
  • this list is quite subjective and not necessarily comprehensive
  • it’s written from the point of view of a backend developer - there are many, many other fields of software, but I mainly focus on backend web development and distributed systems.

# Table of contents

# Databases

Databases are the bread and butter of a backend developer - even if you are mostly dealing with business logic and writing application code, knowing how the underlying data store works can help immensly.

# Relational databases (RDBMS)

Relational databases are the primary persistence layer of most organisations. Therefore it makes sense to place a heavy emphasis on getting to know them well. Amongst others, you might want to:

# NoSQL DBs

  • Know the fundamental differences between SQL and NoSQL databases (also know that the term non-relational for NoSQL might be a misnomer, as NoSQL DBs still have relations - according to this and this source).
  • Know the pros and cons of each, and know where you want to prefer one over the other (do you need a session storage? Do you need atomicity? Do you need transactions? Is vertical scalability essential? Do you need flexible schemas? - questions like these can help to determine which one you need)
  • Read up about MongoDB, DynamoDB, Redis, Neo4J and/or Cassandra.
    • There is a great and fast-paced talk about DynamoDB by Rick Houlihan here at AWS re:Invent.

# Graph Databases

# Data warehouses

# Message queues

While not strictly a persistence layer, queues are used heavily to transport some data (a message) to other components. I would like to look into RabbitMQ, Amazon SQS and Apache Kafka in depth. This IBM article looks good.

# Programming

I’m a Python developer, so this is going to be opinionated.

This is a huge topic, but there are still some general guidelines that I would like to adhere to.

I will strive to know at least 2-3 programming languages at a comfortable level. The choice of language shouldn’t be very important in theory, but it is in practice, because I prefer languages with a thriving ecosystem, good documentation and promising employment prospects.

Python, NodeJS and Go are equally popular nowadays and are fun to learn.
Rust, C#, C++, Java, PHP, Ruby and many others are also fine choices in their own way.
I will probably limit myself to Python, Go, Node and Ruby.

# Language agnostic topics

  • algorithms - as well as being useful for coming up with efficient solutions to real-world problems, having a good grasp of algorithms can help on a traditional coding interview too, so it makes sense to know them well. Sorting, seraching, tree traversals, complexity, bigO notation.
  • Look up SST, LSM, B-tree, DAG (data structures related to storage technology, among others)
  • data structures - similar to the point above, the most common data structures are worth refreshing once in a while. Stack, queue, deque, list, linked list, hashmap, tree, graph, and some more.

    For the two topics above, the Problem Solving with Algorithms and Data Structures using Python material is a good one.

  • design patterns - less popular on interviews, but useful for being able to create good abstractions in code, design patterns are worth reading up about every now and then. See the wiki article for a pretty good read. Some of these are already implemented in higher level languages (e.g. Python has the decorator pattern as a built-in).
  • testing (different levels of testing: unit, integration, contract, etc) an article about unit testing (see also the QA section below)
  • analyzing the performance of your code: profiling, tracing, etc.
  • character encodings, Unicode and character sets

A good resource for this part is the book called “Cracking the Coding Interview” by Gayle Laakmann McDowell. It has tons of good advice for tackling programming tasks on interviews, it inlcudes tons of example quesions and their solutions (with code) for different topics.

# Python

# Tools

  • Version control: knowing git is essential - this might sound obvious, but it’s worth perfecting your git skills, including the less frequently used rebase and bisect commands, using Git hooks, knowing the reflog, and some more (eg.: cherry-picking).
  • Linux command line tools, including:
    • manipulating text with tools like sed and awk
    • processing JSON files with jq
    • searching and sorting (grep, sort, uniq)
  • Automating your local workflows with Makefiles. See how using makefiles can benefit you as a Python developer. See this project for a more in-depth tutorial on Make.

# APIs

# QA

# Operating systems

  • It sounds evident: know the operating system you are working with. In most cases this usually means understanding some Unix/Linux concepts. The Linux Bible is a fantastic book for this. Some other Linux topics to check out:

# Hardware

It is questionable whether it is essential to know any details about the hardware on which your code runs - it’s probably not. However, it’s still an interesting topic worth reading about, and it might make you a more well-rounded engineer.

# Infrastructure

# Distributed systems, software architecture

# Monitoring and Alerting

# Networking

# Security

# Basic math and statistics

# Resources

Most of the resources are inlined in this post, so I’ll just use this section to list some books that are considered classics and that I highly recommend reading.

  • The Pragmatic Programmer by Andrew Hunt & David Thomas
  • A Philosophy of Software Design by John Ousterhout
  • Clean Code by Robert Martin (see some examples in Javascript here)
  • Designing Data Intensive Applications by Martin Kleppman
Written on January 25, 2020

If you notice anything wrong with this post (factual error, rude tone, bad grammar, typo, etc.), and you feel like giving feedback, please do so by contacting me at samubalogh@gmail.com. Thank you!