Go (Golang): The Underappreciated Gem in the SEO Toolbox

Examine the advantages of Go over other programming languages, use it for automated SEO tasks, and run/build your program using this code in both Python and Go.

Compared to a language like Python, which was created in 2007, Go is quite young.

Among its amazing qualities is its lightning-fast execution speed in comparison to interpreted languages.

Among other languages, it is one of the best because of how well it handles concurrency.

It is supported by a fantastic community and is simple to scale.

One of the most important things for me as a technical SEO/SEO developer who creates different tools to automate the SEO process is to develop and deliver code quickly and effectively without sacrificing complexity.

Go (Golang) shines as brightly as the sun in these circumstances.

Automatic SEO

There are numerous approaches to organizing the entire project when it comes to SEO automation.

You have two options: either divide your application into microservices or serverless functions and write each one in the language that works best for it, or write your entire application in a single language and package.

This is not an issue for you if you are working on a straightforward automation task.

As the project expands, though, as an SEO developer, you might run into productivity roadblocks.

An SEO developer is who?

Some sources that you come across when trying to learn more about SEO developers refer to them as front-end engineers with an understanding of SEO.

But we also know that in a perfect website architecture, the app front-end is just a container for the app itself—not the data.

The task of obtaining the data and delivering it to the front end of the app falls to a back-end engineer.

The front-end is in charge of crafting elements like headings, title settings, meta descriptions, and so forth with search engine optimization in mind.

Moreover, some technical SEO specialists are also programmers.

Considering all of these claims, some of us work as SEO developers.

Python, JavaScript, and Go: Select The Appropriate Hammer Depending On The Item

Most SEO experts use Python as our primary coding language.

With Python, we can use frameworks like Flask to code web applications, analyze our data, make charts, and quickly obtain a package that crawls the entire website for us, among other things. Python serves as our all-purpose tool, enabling us to accomplish any task.

However, what if learning a new language could increase our output for some of these tasks?

These languages can be compared in a variety of ways, depending on the type system, concurrency management, etc.

Firstly, I’m going to assume that you are a Python/JS proficient SEO developer.

In most cases, learning Python is a better option for SEOs who are new to coding than learning JavaScript or Go.

My preference for the task is listed below: as an SEO professional, each language can better serve me:

Python: Conducting ML-related tasks and data analysis.

JavaScript: Writing application scripts and using Google Tag Manager as a proficient user. a front-end developer’s interest.

Web application development using Go (Golang). a passion for back-end programming.

Head Facts

Let’s learn more about the Go language.

Proceed with History

You have made the decision to learn Go as your new coding language if you are reading this section.

Let’s take a quick look at Go’s past.

Rob Pike, Ken Thompson, and Robert Griesemer created Go at Google in 2007, and it was released as an open-source programming language in 2009.

It’s intriguing to learn that Python, which was developed in the late 1980s, served as an inspiration due to its simplicity.

Compiled Language Is Go

In addition to the fact that compiled languages run more quickly than interpreted ones, I frequently run into difficulties getting the packages I need, resolving package conflicts, and other issues when I want to run Python code on a different computer.

But with Go, I can quickly write the code for the Linux machine I plan to run it on on my non-Linux computer.

I then copy the executable to the Linux computer using the “scp” command-line tool.

Go Has An Amazing Basic Library

You can explore the standard library of Go, which is one of its amazing features.

Instead of downloading the “requests” package in Python, you can use the built-in package to make a request.

In a similar vein, you can build a web server without installing any extra packages. Often, all you need to do to solve an issue is look through the Go standard library.

Go Is Quick.

There are a number of ways we can evaluate Go’s speed when we say it is fast. A few of these aspects are as follows:

• Because of its simplicity, you can have a nice and fast development experience.
• It’s an effective garbage collection that manages the memory for you.
• Concurrency is one of the things that Go is famous for, and it’s easy to set up (unlike Python).
• Since Go is a compiled language, you get relatively faster code execution compared to interpreted languages.

What Are The Tools For Coding Go?

There are several options for coding in Go. Below, you can see a list of these tools:

• Visual Studio Code (VS Code) – Free.
• GoLand – Paid.
• Vim/Neovim – Free.

Personally, I code in GoLand, but with the IdeaVim plugin that brings Vim motions to my IDE and makes my life easier.

Install the official Go plugin for Visual Studio Code if you wish to use it. Don’t forget to install Go LSP if you prefer Vim/Neovim.

How To Install Go

You can easily follow the instructions the Go website provides to install Go based on your operating system.

How to Write in Go, “Hello World”

Let’s go.

After installing the Go language on your computer and verifying that it’s installed, create a folder wherever you want and name it “hello-go.”

Then, navigate to the folder you created using the “cd” command on your terminal or Windows Subsystem for Linux.

Now that Go has been installed, you can use the Go command line on your computer.

Run the command “go mod init hello” from your command line.

With the help of this command, a “go.mod” file containing the module name, necessary Go version, package dependencies, and other information will be created.

Don’t worry if you don’t understand it yet; just take the time to learn it right now. They are somewhat similar to Poetry if you are familiar with it from your Python projects.

Let’s now create a file called “hello.go” in which to write our code. You can use the command “touch hello.go” to create the file using your terminal.

Let’s start writing our first Go code by opening our text editor or IDE. You can see the code below, and I’ll walk you through it now.

package main
import "fmt"
func main() {
fmt.Println("Hello GO!")
}

Regarding the above code, there are various factors to take into account.

Name of package: We gave it the name “main” to denote that it is our primary Go package.

Statement of import: We imported the “fmt” package from the standard library, which is utilized for formatted input/output, just like we would with Python.

Principal use: This is where Go enters the program to run it.

Perhaps you’re asking yourself right now, “Alireza claimed that Go is simple; what are the above hacks? Python is easier to use, etc.

While there are generally some distinctions between Go and Python, for the purposes of this discussion, we will assume that our functions are written outside of the main function and then called from within it.

Go is aware that it needs to execute the main function when it wants to run our program. Thus, it executes the call to another function if one is present.

The code above will look much more familiar to you if you are familiar with programming languages such as C.

How to Use/Build Our Go Program

We must execute our program after it has been coded in order to see the output “Hello GO!” We use the command “go run hello.go” in the command line to accomplish this.

You are able to observe our output.

Go, as I mentioned, compiles our code; Python, on the other hand, uses an interpreter. Thus, we are able to download and execute an executable file!

The executable file is automatically created and run when we use the “go run” command; it is not saved. Nevertheless, if we run the command “go build hello.go,” we get our executable file as output, which has the same name as the file we supplied to the “go build” command.

The result of executing “go build hello.go” should be an executable file called “hello.” We can use the “./hello” command to run it from the terminal.

Go Code Equivalent Of Python Code

Now that we understand the fundamentals, let’s look at setting up variables, for loops, sending HTTP requests, and other tasks.

For clarity, I will write the corresponding Go code below as well as Python code (which I assume you are familiar with).

The project “Golang for Node.js Developers” inspired me to write in this way. I also created a project called “Go for Python Developers” with as many examples as possible for me, so don’t miss it.

Let’s GO!

Variables

Python:

mutable_variable = 2
CONST_VARIABLE = 3.14 # There isn't a way to define a constant variable in Python
a, b = 1, "one" # Declaring two mutable variables at once

Go:

var mutableVariable int = 2
const ConstVariable float = 3.14
var a, b = 1, "one" // Go automatically assigns types to each variable (type inferred), so you can't change them later.

In addition, the example above demonstrates how to create variables in Go.

You can also see the variations in commenting styles and variable naming conventions between Go and Python.

Data Types

Python:

string_var = "Hello Python!"
integer_var = 2
float_var = 3.14
boolean_var = True

Go:

var string_var string = "Hello Go!"
var integer_var int = 2
var float_var float = 3.14
var boolean_var bool = true

For loops
Python:

i = 10
for i in range(10):
print(i)

Go:

// Initial; condition; after loop
for i := 0; i < 10; i++ { // Using the shorthand syntax of declaring a variable in Go (mutableVar := the value)
fmt.Println(i)
}

While loop
Python:

counter = 0
while counter < 5:
print(counter)
counter += 1

Go:

var counter int = 0
for counter < 5 {
fmt.Println(counter)
counter += 1
}

If/Else:
Python

age = 25if age >= 13 and age <= 19:
print("Teenager")
elif age >= 20 and age <= 29:
print("Young adult")
elif age >= 30 and age <= 39:
print("Adult")
else:
print("Other")

Go:

var age int = 25
if age >= 13 && age <= 19 {
fmt.Println("Teenager")
} else if age >= 20 && age <= 29 {
fmt.Println("Young adult")
} else if age >= 30 && age <= 39 {
fmt.Println("Adult")
} else {
fmt.Println("Other")
}

List/Slice

We are acquainted with dynamically sized lists in Python. For Python lists, there are two distinct ideas in Go. An array is the first, and it has a fixed size; slices, on the other hand, have a dynamic size.

Another crucial aspect of Go’s arrays and slices is that we have to specify the kinds of elements we wish to keep in them. Stated differently, a slice of strings is what’s possible, not a slice of both strings and integers.

Python:

mix_list = [False, 1, "two"]

Go:

var boolArray [3]bool = [3]bool{false, true, true} // var variableName [array size]type of array elements
var stringArray [3]string = [3]string{"zero", "one", "two"}
var intArray [3]int = [3]int{0, 1, 2}
var boolSlice []bool = []bool{false} // var variableName []type of slice elements
var stringSlice []string = []string{"zero", "one"}
var intSlice []int = []int{0, 1, 2}

For loops Over Arrays/Slices
Python:

mix_list = [False, 1, "two"]
for item in mix_list:
print(item)

Go:

var intSlice []int = []int{0, 1, 2}
for index, value := range intSlice {
fmt.Println(index, value)
}

Charts

Think of Map as the Python equivalent of a dictionary. The key and value types need to be declared, just like with an Array/Slice.

Python:

the_dictionary = {"hi": 1, "bye": False}
print(the_dictionary["hi"])

Go:

var theMap map[string]int = map[string]int{"hi": 1, "bye": 0}
fmt.Println(theMap["hi"])

HTTP Get Request
Python:

import requests
response = requests.get("https://example.com/")
print(response.content)

Go:

import (
"fmt"
"io"
"log"
"net/http"
)
resp, err := http.Get("https://example.com/")
if err != nil {
log.Println(err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
fmt.Println(string(body))

In summary

You can check out the Go Tour and the Go by Example website (I used the hierarchy of examples for this article) if you’re interested in learning Go.

Happy learning and I hope you enjoy coding in Go!