Go
programming language
The Ultimate Beginner's Guide to Learn Go Programming Step by Step
By John Bach
3 nd Edition
"Programming isn't about what you know; it's about what you can figure out . - Chris Pine
Memlnc.com
Introduction ...5
Chapter I
General concepts.6
Chapter II
Understanding go...19
Chapter III
Writing the first program......34
Chapter IV
the rules...53
Chapter VI
Create Backend..84
Introduction
You may have heard in the last few years about a new programming language that originated from within Google called Go (or Golang as a searchable term for search engines), through this book we will try to identify this language, its advantages, disadvantages and what makes it different from others. The first chapter of this book will be a verbal lesson only, focusing on the points of difference of language with the rest of the languages, and is directed to those with some programming background with the rest of the languages, but the rest of the lessons will be directed to beginners.
Chapter One
General concepts
As usual every decade, there are new tools and techniques that try to take advantage of the mistakes of their ancestors from tools and techniques. And "What is the need for a new programming language?" Or "Why don't they agree on a single programming language?", A programming language is just a tool for your tasks, each of which is more appropriate for a task. Choose for each task the most appropriate tool, and there is no need to sanctify the tool and the establishment of war wars - non-technical - around them or create an imaginary obsession prevents learning.
A team of programmers from within Google felt it was time to improve their workflow in C and ++ C, and they needed a new tool that eliminated the flaws of those two, further improved their productivity, and was relevant to the quality of Google's computational needs. They founded the Go programming language within Google in 2007. The long established team of the language includes Unix's founder, Ken Thompson (a computer science, Ken) who worked for Bell Labs, and Robert Pike, who was also part of Bell's Unix team. Labs, one of the founders of the UTF-8 codec, and finally Robert Griesemer is a V8 JavaScript engine worker.
Knowing this simple historical overview of Go, I like to kill you all overly enthusiastic, I don't like you to love programming language because of its founders, or it came out of a company you love, so I will start to list things you may not like about the programming language Go, even if you did not like it , You might want to stop reading. I would be personally happy to see very few readers of this series really knowing what they are doing, rather than a momentum enthusiastic about everything new without awareness and knowledge of things.
Things you may not like about the Go programming language
1. Object-oriented is not
If you think it is, there is no concept of Class or Objects and therefore there is no inheritance. However, Go carries some of the advantages of object-oriented programming such as the provision of Interface, Structural Functions, and Struct composition.
Why? The founders of language believe that object-oriented languages carry many flaws and complexities that can be eliminated by abandoning some of these concepts altogether. Even Java programmers themselves recommend Composition, for example, more often than inheritance, language founders who believe that object-oriented programming is often a bad idea, technically.
2. No Exception Handling handled
This may be a corollary due to the absence of Go's concept of object programming. Go errors are handled in a fairly traditional way, since errors are returned as normal error values. Where error is a primitive type in itself as any other native type (int, string .. etc). However, Go allows you to throw an error for exceptional cases via the keyword panic (similar to raise or throw in other languages) as well as recover from these errors by recover.
3. No default or optional arguments can be passed to functions (default / optional arguments)
In other programming languages, you might be used to doing something like:
function listFolders (path, subfolders = false, recursive = false) {...}
In Go, however, you cannot pass subfolder = false nor recursive = false as a sign to the listFolders function because it will not accept such default / optional parameters, resulting in a compile error.
Why? Language founders believe that these behaviors contribute to building unstable APIs or make their behavior unpredictable. In our previous example, for example, they prefer to write the function without default operators, ie:
func listFolders (path string, subfolders bool, recursive bool) {...}
This forces you to write the behavior you want from the function explicitly instead of letting the code interface dictate you to act as the default, this to reduce human errors. This may also prompt you to write three functions, each with its own distinct behavior, for example: listFolders, listFoldersRecursivly and listFoldersWithFirstLevelSubFolders.
4. No Overloading feature
For the same reasons, there is no Method overloading, ie you cannot redefine a function with the same name but with a different signature. For example, if there is a function named:
func listFolders (path string) {...}
You cannot create another function with the same name but with a different signature such as:
func listFolder (path string, level int) {...}
You should change its name to:
dunc listFolderToLevel (path string, level int) {...}
However, there is an indirect way to make a function accept arbitrary values by making the {} interface type signature we will look at in the next lessons.
5. No generics
Other languages enable you to write generic functions or classes, where you do not declare the type of parameters you accept but leave them to know the type of parameters later when you call them. A type to be determined, so String or Integer can be easily created while maintaining the same functions and operations that can be performed on the List in general.
There is no Go like this, and instead there is a {} interface as a universal type that satisfies all types, but it is not a perfect alternative to Generics.
Why? The reason for the lack of Generics in Go is that its founders have not yet figured out the most appropriate way for them to add this feature to the language without increasing load during run-time.
6. Go is a boring language and is not the best programming language!
Because of the simplicity of language and nothing new, many consider it a boring language. The number of keywords and their original types is small compared to other languages, and they greatly reduce the existence of more than one way of doing a task. It doesn't even have a while loop and is limited to a for loop. Many consider this a feature of language, but I mentioned it to you so you don't expect anything new to show off.
Also, the language will not allow you to leave a variable without using or importing an unused import / variable and the compiler will never accept it.
7. Stubborn language
The founders of language are firm in their opinion and decisions in the design of the language, do not expect significant changes that may occur in the short or medium term in the language or changes in the way things do and the behavior of the compiler. There is no need to open blank discussions about language design and its flaws unless you are at the same level of experience and wisdom.
