Introduction
Why should you learn Go?
Some people have different opinions, but there are certain features that are pretty understood as being advantages of the Golang. So, some of the advantages of Go.
1. Code runs fast
Go language is running fast, that’s always a good thing, and we’ll discuss a little bit more detail in this post about why it runs fast, and faster than what. Does not run fast than everything, but it runs fast than a lot of things.
2. Garbage collection
The garbage collection is automatic memory management. That is similar languages, meaning languages that run fast as Golang does, they don’t have garbage collection. So, garbage collections are a really useful feature.
The garbage collection is the automatic memory management, where should memory allocates, “We need a variable x. Where should we put it in memory? What type of memory we should put it in, but also when we have done with that memory. you’re done with the memory, you can get rid of a memory. You do not have to use it anymore, you can use it for something else. The garbage collector can figure that out when the program is done with variable x, and free that memory now, that happens automatically.
Manual memory management is hard. because, if you have ever done C or something like this and it deallocates memory too early if you stop using it too early. then will get false memory accesses, and if you need it. then use the memory that’s already deallocated and errors crop up because of that.
Golang has a garbage collection code included. So when it compiles your code, it also compiles garbage collection into your code automatically, and this is typically only done by the interpreter. So, Go programming is a compiled language that actually has garbage collection, which is a really good feature. Now, the downside is that it slows down execution a bit. and it is an efficient garbage collector, so it doesn’t slow down much and you get a lot of advantage of having this automatic garbage collection.
3. Simpler objects
Golang is essentially object-oriented although, some might disagree, it has this concept of objects. inside Go object orientation is a little simplified as compared to other languages. So, this is good, it makes it easier to code and makes it faster, and simpler to use. Golang is actually a simpler object-oriented implementation than you would see in other languages like C++.
3. Concurrency
Another feature of Golang is that it has efficient concurrency implementation built into the language. the Golang has a lot of concurrency primitives that are built into the language, and that are efficiently implemented.
Let’s go and understand why code running is the fast thing and discuss the languages in general, differences between languages. So, we have the following three categories of languages for machines.
1. Machine language
Machine language is the lowest level language, and it’s directly executed on the CPU, on the processor. So, the machine language instructions are uncomplicated and simple, add, multiply, add might add to register contents, put the result in another register, something like that, very small steps, each machine language instruction.
2. Assembly language
The Assembly language is fundamentally machine language, almost a one-to-one mapping to machine language. So, in machine language, say you had to add instruction that represents as a sequence of zeros and ones, 11110000 that might be an add, Opcode for an add.
So, in the assembly language, you would use the word ADD instruction. So, it maps one-to-one to the machine language equal, but you can read it because it’s English. Now, it’s concise English, it’s hard to read, but it’s English mnemonic, so a human could read that and could right that if you wanted to, and people do sometimes.
3. High-level languages
A high-level language is a language that fundamentally humans commonly use to program in. so it is much easier to use than assembly language or machine language. It provides you with lots of abstractions that any program uses to, for instance, variables, right? Assembly language and machine language do not have variables, they have memory, and you can put stuff in it or take out.
The Assembly language and machine language, they both have conditional branches and so on. but it generally much harder to use than your standard. if statement that you would see in any normal high-level language for loops, or loops things like this. You can create these things in assembly language and machine language, but they are harder to write than they would be in a high-level language. So, high-level languages are basically everything that why most people program in.
So, you can imagine these different categories. Now, the language that we discuss Golang. the Golang is a high-level language in this set of three categories, it will consider high level. So, all software needs to translate into the machine language of the processor to execute. So, what that means is, that if you’ve processor whatever you’re working with. that processor does not know C or Java or Python or Golang or C++ or any of those, so it knows that machine language. So, the first order code executes on the processor, it has to be first translated into the machine language of the processor.
4. Compiled
The compiled language is a language where the translation from high-level language to machine code happens one time before you execute the code. before you deploy the code, happens one time. So, like in C, C++, Golang, Java partially, there’s a compiler, and you compile the code. So, if we write the source code, they compile it, and then they execute it, and they execute the compiled executable. The compiled executable is machine language code plus other stuff, but it’s machine language code. it doesn’t occur while you’re running the code. It happens before you run the code, and then when you run the code, you are running the machine language instructions because they’re already compiled into machine language by the compiler.
5. Interpreted
In the interpreted language what happens is, instructions are translated period of time the code is executed. So, It happens adds time to the execution because every time you see instruction and say Python, that code, that instructs. So, In the Python occurs translation every time you run the Python code, say or Java, the Java byte code. we put Java as partially in both categories because Java it’s compiled, but it generates what’s called byte code, not actual machine code and then the byte code interprets at runtime.
Now, interpreters make coding easier. So, the interpreter itself, that program that is doing the translation of your code.
That’s why Golang is a good compromise between this compiled and interpreted type of language. It’s a compiled language, but it has some of the good features of an interpreted language, it has garbage collection. ion has to be translated into machine code, and that takes a certain amount of time to do that translation. So, besides to actually executing the instruction, you’ve got to do this translation from the instruction into the equal machine code, so that slows you down.
