How to become a Golang developer: 6 step career guide
Tags: go, google, career, language
Published: 2021-03-09 21:39:19

> **Note:** *We recognize that every person has a different career path when it comes to Go. This is not meant to be a definitive guide but rather a rough outline of the skills to learn. If you've had a different experience as a Go developer, please share them below.* 

Golang (also called Go) is an in-demand programming language, especially for people working with Google products. Go is used by many big companies, like Uber Medium, Dropbox, Salesforce, Netflix, IBM, and Twitter.

Go is a great option for job seekers of all levels. *But how do you get started? What do you need to know?* Today, we will discuss the best path for learning Go and building a solid portfolio. 


**This career guide at a glance:**
* [What is a Go developer?](#what)
* [Step 1: Learn the basics of Go](#1)
* [Step 2: Master Go libraries and other tools](#2)
* [Step 3: Learn testing with Go](#3)
* [Step 4: Understand Go patterns](#4)
* [Step 5: Start building your  portfolio](#5)
* [Step 6: Practice Go coding interview questions](#6)
* [What to learn next](#next)

<a name="what"></a>

## What is a Golang developer?

Golang (also called Go) is a **statically typed, compiled programming language** that was developed by Google in 2009. The language combines the efficiency of C++ efficiency and the readability of Python. 

Golang developers use the Go  language to **build webpage and software products.** A Go developer's general duties include working with Go and using its **full suite** of tools and frameworks. Most Go developers also do testing and debugging.

Most job postings for Golang developers require a wide variety of other skills as well, the most common being:
* Experience with scripting (Shell/PERL)
* Experience in application design using [design patterns](https://www.educative.io/blog/the-7-most-important-software-design-patterns)
* Javascript, SOAP, REST Webservices, or [Microservices](https://www.educative.io/blog/microservices-architecture-tutorial-all-you-need-to-get-started)
* Experience using Git
* Knowledge of DevOps practices


The entry threshold for Go is **relatively low**. It's an easy language to learn and comes with a detailed technical documentation. Switching to Go is relatively easy for those who have C-language experience. So, if learning Go is easy, how do you actually get a job working with the language? *Let's break it down.*

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5te7iyaqiwy9airu9sdv.png)


<a name="1"></a>

## Step 1: Learn the basics of Go

To become a Go developer, you need to have a **solid understanding** of the language and syntax. You can start by installing the language and teaching yourself, or you can take an online course to guide your learning. The good path for learning Go will look something like this:

1. Filenames, keywords, identifiers
2. Operators, types, functions, and constants
3. Pointers, structures, methods 
4. Maps, arrays, slices
5. Go CLI
6. Interface 
7. Error handling
8. Goroutine, Channel, Buffer
9. Panic, Defer, Error, Recover
10. Go design patterns

Your learning path will largely depend on your background. If you are **completely new to programming**, Go is a great first choice. It is easy to learn and mimics other popular languages like Python and C++. For new learners, it's best to start with the basics like [filenames, keywords, and identifiers](https://www.educative.io/blog/golang-tutorial#basic). Then, you can build your foundation with data types, operators, and and strings. 

If you already have **some programming experience**, it's also recommended to learn Go from scratch, starting with the unique characteristics of Go. Go is built on a different model than what you're used to, and it treats [object oriented programming](https://www.educative.io/blog/object-oriented-programming) differently.

Go aims to reduce typing and complexity using a minimal amount of keywords, so you will code less than other languages like Java. Keywords can be parsed without a symbol table, as its grammar is LALR(1). Go acts like a hybrid, imperative language, but it is built with concurrency in mind.  Here are some of the unique features of Go: 
* No function or operator overloading 
* No implicit conversions to avoid bugs 
* No classes or type inheritance
* No variant types
* No dynamic code loading or dynamic libraries 
* No assertions or immutable  variables


```go
package main
import "fmt"

func main() {
    fmt.Printf("Hello World")
}
```

<br>

<a name="2"></a>

## Step 2: Master Go libraries and other tools

Once you have the basics of the language down, you should move onto the add-on libraries and tools that make Go easier to use. Most companies will expect that you have experience with:
* Go dependency management tools
* Semantic versioning
* Scripts and repositories 
* Go libraries 
* SQL fundamentals 
* GIT 
* Basic authentication 
* HTTP/HTTPS
* Web frameworks and routers 
* Relational databases (PostgreSQL)

> If you already have some programming experience, you may have some of these under your tool-belt already. If not, don't panic! You will learn most of these skills as you learn how to build with Golang and related technologies. 

The most important extra things to learn are frameworks, Go libraries, and databases. Many of the other skills can be learned along the way or on the job. 

In terms of **frameworks**, is recommended to start with the web frameworks Echo, Beego, Gin, Revel, and Chi, with **Echo** being the most important for Go. 

In terms of **libraries**, the most popular Go libraries are Go Kit, GORM, Gen, and CLI. Using  good libraries and packages will make working with Go even easier. Each will have their own unique features, so it's a good idea to pick one that aligns with your goals. 


In terms of **databases**, it's important to have some experience with relational databases, such as [PostgreSQL](https://www.educative.io/blog/mongodb-versus-postgresql-databases) or [MySQL](https://www.educative.io/blog/mysql-tutorial). Beyond that, knowledge of log frameworks can be useful, with Zap being the most important for Go. 

<a name="3"></a>

## Step 3: Learn testing with Go

Testing is an important skill that most companies will be looking for. [Software testing](https://www.educative.io/blog/software-testing-types-101) is how we check if the actual software product matches requirements and actually runs properly once distributed.

As a Go developer, you'll be building products for the real-world, so you need to **test your products** for usability and reliability. This includes:
* Unit testing
* Integration testing
* Behavior testing
* E2E testing

**Unit testing** is arguably the most important for new Go developers. There is a built-in `testing` package in Go’s standard library. But, Go errs on the side of minimalism, so you may need additional tools for more robust testing, such as popular frameworks Ginkgo and GoCheck. Ginkgo can also be used to behavior testing and integration testing. 

<a name="4"></a>

## Step 4: Understand Go patterns

Most employers want to see that you understand Go's design patterns. A design pattern is a repeatable, general solution to a commonly problem in software design. Different design patterns help to divide business logic or define structure to help with certain tasks.

Go offers similar [design patterns](https://www.educative.io/blog/the-7-most-important-software-design-patterns) to other languages that fall under these general categories:
* Structural 
* Creational
* Behavioral
* Concurrency 
* Stability

The most important are **creational** (such as builder, factory, singleton), **behavioral** (such as iterator, observer, command), and **structural** (such as adapter, bridge, decorator). 

If you are already a programmer, you may be familiar with design patterns and can start learning them in the context of Go. If you're new to programming, the best way to learn these is to actually begin coding with them. Borrow some sample implementations and build around them. 

<a name="5"></a>

## Step 5: Start building your  portfolio 

Once you have these steps down, it's time to **start building things** for your portfolio. This is how a company will see that you have real experience working with Golang. Also, it's proven that the best way to master a language is to build functioning products with it, so the more you build, the more you learn. 

Building out a portfolio includes:
* Completing online courses on Go
* Contributing to open source Go projects
* Building Go projects from scratch 
* Implementing Go units in existing projects 
* Coding classic algorithm problems with Go
* Completing courses on adjacent technologies (i.e. SQL)

You can really build anything you want to put your skills into practice, such as to do lists for personal needs, demo websites, puzzles, games, and coding challenges.

Start with an online course that **offers a certificate**. You can add this to your resume to prove you have the basics down. Then, focus on [open source contributions](https://www.educative.io/blog/git-github-tutorial-beginners) on GitHub. This demonstrates that you can build real projects and know how to use a popular version control system.

 
<a name="6"></a>


## Step 6: Practice Go coding interview questions

Once you have a solid portfolio, you can start practicing Go interview questions. This will help you prepare for interviews and learn more about the language you've just learned. Coding interview questions are not the end-all-be-all since they tend to be abstract, but they can really improve your code and help you work under pressure. 

When you get an Go developer interview, you'll be expected to answer these questions in time, so getting practice early on can't hurt! It'll also help reveal any **gaps in your knowledge.** 

Some common questions include:
* What is a goroutine? How do you stop it?
* How do can check variable type at runtime?
* How do you format a string without printing?
* How do you concatenate strings in Go?
* What is Go 2?
* How do you initialize a struct in Go?

<a name="next"></a>


## What to learn next

Congrats on making it to the end! You should be well on your way to becoming a Golang developer. Clearly, there is a lot that lies ahead. Where you start largely depends on your base knowledge, but it's recommended to learn Go from scratch. **Your next steps should be:**
* Learn Go syntax 
* Understand basic data types
* Build something using control structures
* Get practice with functions

To get started with Go, check out Educative's course **[The Way to Go.](https://www.educative.io/courses/the-way-to-go)** You will learn the core constructs and techniques and dive intro advanced Go concepts like error-handling, networking, and templating. 

*Happy learning!*

<br>

### Continue learning about Golang and Google
* [Getting started with Golang: a tutorial for beginners](https://www.educative.io/blog/golang-tutorial)
* [Cracking the Google Coding Interview: the definitive prep guide](https://www.educative.io/blog/google-coding-interview)
* [The 7 most important software design patterns](https://www.educative.io/blog/the-7-most-important-software-design-patterns)