GO PROGRAMMING LANGUAGE

PROS:

---

1. EASY SYNTAX

This is actually one of the best features of Go. The syntax is easy. The keywords are pretty few. You can get an understanding of it in a few days or hours. This has a direct impact on point...

If you have a C background you'll love Go for its almost similar syntax.

2. RAPID DEVELOPMENT & TEAM BUILDUP

Due to its easy syntax Go can be used fr rapid development of features. Also, a business can get to build a Go programming team quickly.

3. EASY & SIMPLE TOOLING

Go only requires you to download and install its binaries and you are good to go.

4. TRUE CONCURRENCY OUT-OF-THE-BOX

The developer of Go is Google. Their premise for developing it was to have a programming language that could offer lightweight concurrency on their systems. Go comes with Goroutines that offer this important feature right out-of-the-box. And Goroutines are pretty lighweight; you can spin thousands on a single thread with minimal impact on a system's resources.

5. SOLID BACKING

As pointed out in point #4, Go has the added benefit of having a major backer - Google - behind it.

6. SMALL BUILDS

Go produces small binaries after compilation.

CONS:

---

1. PRIMITIVE SYNTAX

While it has simple syntax it tends to suffer a lot from "Boilerplate Coding". Too much

if err != nil

everywhere. Very few generics. Error bubbling is still not a thing in Go. And if you are coming from an OOP background you might find the lack of encapsulation, polymorphism, DI, Inversion of Control etc pretty surprising.

2. UNSAFE CONCURRENCY

While Go's concurrency is its major strength it is also its weakness. If a programmer is not careful they could land into the abyss of concurrency deadlocks and race conditions.

3. WEAK TYPE SAFETY (IN COMPARISON TO RUST)

Go's compiler can nab most type errors during compilation but sometimes can quietly allow others to pass. These errors could soon popup during runtime.

4. DANGLING NIL POINTERS

A pretty common problem in Go programming that produces UB (Undefined Behavior).

5. SMALL PACKAGE REPOSITORY

In today's world, a programming language needs to have a package repository that extends its standard library. Think NPM for NodeJS, Composer/Packagist for PHP. Go has its own package repository but it is rather small with few packages. Take the case of Session Management in Go applications. The most recommended package is Gorilla. Unfortunately, the original developer of the package abandoned it. Google simply took over its maintenance but since then receives few pull requests and improvements.

RUST PROGRAMMING LANGUAGE

PROS:

---

1. ROBUST TYPE SAFETY

A feature that hardcore programmers look for. Rust has such strong type safety that it cannot compile at all if it detects the slightest violations. One such violation is the borrower/ownership violation. Every variable in a Rust is immutable by default. You cannot change the variable and its value once instantiated unless you use the keyword

mut

. And let's not talk about lifetimes and just how hard it is to manipulate stuff that is in an

<Arc()>

.

If you are a programmer who really has a fondness for safe programming you'll fall in love with Rust. It's variables are immutable by nature and the entire programming is confined within the "Safe Writing Mode" unless you explicitly define a code block as "unsafe". Isn't that beautiful?

2. SOLID ENGINEERING OUTPUT

Due to its strong type safety a programmer is sure that the output will work correctly anywhere. Obviously, this does not mean that Rust applications are 100% failproof.

3. BETTER MEMORY USAGE

Rust's "zero cost abstractions" and the lack of a Garbage Collector offers better memory usage. Some benchmarks have shown that Rust does outperform Go in its throughput while using less memory.

4. TWO CONCURRENCY MODES OUT-OF-THE-BOX

Rust uses the Tokio library for concurrency. The beautiful thing about it is that it has 2 modes of concurrency. On one hand, the

Async/Await

paradigm offers event-bound IO concurrency to every function but a programmer can still

tokio::spawn(async move {...})

a thread within a function just like in Go's

go func()

concurrency model.

5. BIGGER PACKAGE REPOSITORY (THAN GO)

Rust's Crates repository has a bigger collection than that of Go. You can get more libraries to extend Rust's standard library than you can get on Go's ecosystem.

CONS:

---

1. DIFFICULT SYNTAX

Rust has not only a large keywords dictionary but its syntax is pretty difficult. Add to the complexity is the underlying borrower/checker/ownership paradigm.

However, for any C++ programmer, Rust's syntax may seem similar.

2. ASYNC/AWAIT CONCURRENCY IS NOT TRUE CONCURRENCY

The

Async/Await

paradigm is not "true" concurrency. Similar to that used in NodeJS, the

Async/Await

paradigm simply tries to achieve concurrency through what is called "cooperative multitasking" where a single thread is used and each activity is started/completed in rapid sequence based on "events". True concurrency on the other hand is built around the spawning of new threads to accomplish tasks.

3. LONGER COMPILE TIMES

Rust tends to have a slighter longer build time than Go.

4. LARGE BUILD TARGETS

During compilation Rust tends to produce a "target" folder where the final binary resides. This folder is usually large (in megabytes) for even small single file Rust applications. If you have a machine that has little disk space left you could find Rust development annoying.

5. SLIGHTLY COMPLICATED TOOLING

...but not as complicated as C/C++ tooling ;-)

Setting up a Rust development environment can be a bit challenging especially if one is a newbie to programming. You need to set up its linker libraries and so on. On Windows this comes with Visual Studio C++ development tools while on Linux distros you'll need to install "build-essentials" to get that build kit for your Rust dev work. Compare this with Golang where the only requirement is installing Go development binaries and nothing else.

One more thing, the Rust development tools can be really huge. The Visual Studio SDK alone is more than 1 GB in size.

So which is the best? It depends on what you want to build. Want to produce solid software that uses system resources better under load? Use Rust. Want to quickly spin up a web service or API that has lightweight concurrency? Use Go.