Go Language Characteristics
Go language has following characteristics
1. Strong static type system
This means is that every symbol, every keyword that you type within your Go programs has a meaning for the compiler, and those meanings can't change over time. So when we declare a variable of a certain type, maybe it's a string, that variable will always be a string, and the definition of a string will not change throughout the execution of the program. This was done as a way to introduce simplicity and support for developers as they're working with Go because a strong static type system allows tooling to be developed that reinforces and supports the engineers that are creating GO code to help them understand and identify errors early on in the development process.
2. C‑inspired syntax
C is one of the most popular syntaxes in the world today. So whether you're using C++ or JavaScript or Java or Python, all of those languages derive their basic syntax from C. So, in order to embrace simplicity and allow Go to be recognized by the widest possible audience, the C syntax was used as the basis for the language.
3. Garbage collected
Now this was actually a controversial decision when Go came out, but let's think about why Go might have selected to use a garbage collector. And once again, it comes back down to simplicity. By having a garbage‑collected language, which does have performance ramifications, but we allow developer ergonomics to be increased, and managing Go programs is simpler because we don't have to worry about cleaning up after ourselves when we're done using memory. When we're done using a variable or an object, Go recognizes that, and it's going to clean the memory up for us.
4. Fully compiled
Now this gets to the idea of having efficient execution. We want fully compiled languages so that every time you're running Go on a system, the compiler has the opportunity to tune and optimize the compilation process and the resulting binary to work optimally with that system. So in order to achieve that to the greatest degree possible, Go does utilize full compilation as we build our Go programs.
5. Rapid compilation
Go fights very hard to combine and balance these two(fully compiled and rapid compilation) requirements. Most Go programs compile so quickly that it almost looks like you're running a scripting language like Python. This is done by heavy optimization of the Go compiler. And you notice that asterisk way back when said C‑inspired syntax? That asterisk is there because what we see with Go syntax is that sometimes the ordering and the symbols that we use are actually chosen to speed up and accelerate the compilation process. So by doing that and having this rapid compilation experience, we allow programmers and engineers to stay in the problem‑solving mindset and not be distracted waiting for their programs to compile.
6. Single binary output
Go opts for a single binary output as its default compilation artifact. This means that while you can have shared libraries in Go, that is not the norm. Instead, Go compiles everything, all the libraries and main application code, into a single binary for deployment. This makes deployment with Go often trivial because all you need to do to deploy a Go application is copy the binary to the container and start the container up. And so deployment scenarios are simplified, and the management of Go programs in production is often very, very simple because we only have one file to worry about.
7. Cross‑platform
Go is cross‑platform. The nature of software development today is that software will be executed on different platforms. So you might be using a Mac for your development. You might deploy to a Linux cluster. You need the same code to work in a reliable, consistent manner across those different platforms. So Go, like many other modern languages, supports that through having platform‑specific compilers that take a common codebase and compile that down to a binary that's optimized to run on each given platform.
Reference
Pluralsight- Go: The Big Picture