There are many prominent companies that use Go. Primarily what we’ve seen is that whenever a company is hosting and providing media, like Netflix, YouTube, or SoundCloud, you’ll find Go.  

A lot of on-demand services like Uber and already using it too. The same can be said about anyone looking to create applications that emulate these tech giants. For example, if someone comes to us wanting to create something like Uber, we develop the front end in a native language like Swift for iOS and Kotlin for Android. When it comes to accessing the backend server, Go is a great option, as it’s concurrency can handle thousands of requests in parallel. We’ll talk more about concurrency later. 

Now let’s look at some other ways Go is used.

Go can be used for web development using WebAssembly. It’s not a replacement for JavaScript because JavaScript is still the ruling platform, but WebAssembly works along with it. So, if you have some code that needs higher performance, you can write that small piece of code in web assembly and use it along with JavaScript.

Knowing this, we can now compile our Go code into a web assembly binary file. You can continue writing with Go, collect or compile it into web assembly, and then you can use that in your browser.

Gopher JS is a transpiler. A transpiler is something that compiles one language into a different language. It compiles the current code written in one language into a machine code binary or a bytecode like in the case of Java. GopherJS is written in Go and converts Go code into JavaScript so you can continue working on your project. It supports every syntax and every feature of Go. This is another way of using Go in a browser other than compiling it into web assembly.

Go interfaces with different types of programming languages and is a universal or general-purpose language. No matter if an app is written for iOS, Android, or Cross-platform, you can use Go to establish a link between the front and back ends of the application.   

Suppose you already have a system built with node JS on the backend and Swift for the front end for iOS. In this case, A small section of code can be used to achieve greater performance to handle more requests in parallel and that small piece of code can be written in Go.  

Then you can use a message queue to interact between your nodeJS portion of the code and your Go portion of the code. That’s essentially a pipeline where two processes can communicate.

Go code can run on Raspberry Pi. To run on Raspberry Pi, there is one Go compiler called TinyGo. You can use that to compile your code and get the binary to run on Arduino microcontrollers as well. So like Go , TinyGo is also backed and supported by Google. It’s still in its infancy, but you can write code using Go and then use TinyGo to compile it into binary that can run on microcontrollers.

Another way to use Go is for Microservices, to help speed up mobile applications. This is how we at Zco primarily use the language. 

You can breakdown a large system into different tasks that we’ll refer to as A, B and C. To tackle these tasks, we write microservices in Go. 

We then have a message queue that is used to communicate between each of these microservices. The beauty of this is that it can handle requests in parallel. If task A is highly backed up and having issues, that means the users are accessing a specific feature in the mobile application that requires task A to work more. 

So what you do is scale task A by putting a load balancer in front of it. This means you don’t have to scale up Task B or C so you are saving on resources in terms of processing power and not getting other services bogged down. So based on what features are getting more traffic in the app you can precisely scale that microservice, and that’s the beauty of microservice architecture.  

If we are putting this into layman’s terms you can think of a grocery stores checkout line. There are 4 lanes open the weekend before thanksgiving. If the employee on lane 1 is getting slammed by shoppers with their hundreds of items, you can switch that person out for someone who maybe has some more experience. More seasoned employees. This represents the load balancer. In this example all of the lanes would have the same function or job, but it paints a picture about having several services functioning at the same time.  

Concurrency means you’re running tasks in parallel. It means you are time slicing the functions, allowing the processor some time to take on function one, then jump to function two, then jump to function three. So, in the end, it looks like it’s all running in parallel. 

Go is especially useful for making concurrent programs. The difference between Java and Go, and other languages like C or C++, is when you want to write simultaneous functions.  

Go has a unique feature that is built within the language that’s called Go routines. The beauty of it is that Go routines are so lightweight you can have millions of Go routines running and doing the job on a simple medium memory server.  

In terms of speed, Go routines are lightweight compared to the threads that Java uses. It’s also worth noting that writing a code to make it concurrent in Java, C or C++ is more difficult.  

Really, what you want in a web server is the ability to handle hundreds and thousands of requests in parallel. Go is specifically built for that and is hugely scalable.

Go provides a mechanism called garbage collection. What it does is initiate a small routine that runs alongside your code and keeps checking for unused memory. While running this routine, it will keep asking until it can remove the background process. 

In C or C++, you will need to clear that memory, or heap, manually. If you don’t do it, it will waste the memory capacity, and ultimately, the program will crash because of lack of memory. 

That being said, you don’t want to run garbage collection too often because your program will become slow. Thankfully, Go has an excellent enhanced garbage collector built in.  

To give an example, it’s like you‘re in a boat that’s filling up with water. You grab a bucket to shovel out the excess. The garbage collectors basically scooping out water to make sure you stay afloat. 

With the recent improvements from Go releases, the garbage collection has continued to improve even more.

So, why did we a Zco start using Go? Well, we were looking for something that could scale as our projects grew in size. At the time, we were only focusing on .NET and NodeJS, and we needed something that developers could learn quickly.   

We primarily use Go for web server development; for working with rest APIs and any background services. For example, if someone requests for an image to be processed, the request comes in, and then we run a background service that is running Go.  

One of the early programs that needed Go was a consumer-facing application because that’s where scalability comes into play. Tons of random users numbering in the thousands logged on to use the service. That creates a strain on connection speed and performance. It was also graphically intensive and needed more microservices to make sure that the connection was smooth. In popular games, the back end should be running something that can simultaneously scale and handle thousands of requests. Go is a good fit for that.  

We also plan to use Go on the front end to build web apps that run on browsers. We can do this by leveraging WebAssembly.