The goal of this post is to introduce what the Go language is and why it is so powerful. Introducing some concepts and important points about the Go language that are often mistakenly expressed in several articles found on the internet and discussion groups of programming languages. I believe that the weaknesses and problems generated by several other programming languages ​​over these decades made Go become what it is today. And to explain how this is possible we will go back to the beginning of everything, where everything began.

package main

func main() {
    println("Hello all folks!")
}

Less is exponentially More

The Go development team says that its creation is an attempt to make programmers more productive. Improving the software development process on Google. The first goal was to create a better language to address the challenges of scalable concurrency, ie software that handles many concerns simultaneously, an example would be coordinating a thousand back-end servers sending network traffic all the time.

Keeping the Go language small allows for more important goals. Being small makes Go easier to learn, easier to understand, easier to implement, easier to re-implement, easier to ** debug**, easier to tweak, and easier to evolve. Doing less allows for more. It's an expression used by the Go development team: “Do Less. Enable More” would be the balance between the universe of existing problems and what Go can help solve such problems well. Go explicitly wasn't designed to solve every problem instead they've done enough for us to create our own custom solutions with ease, but making it very clear that Go can't do everything.

Go was designed by Google in 2007 to improve programming productivity in an era of multicore, network machines and large codebases. The designers wanted to address criticisms of other languages ​​in use at Google, but keep their useful features.

The creators Rob Pike, Ken Thompson and [Robert Griesemer](https:/ /de.wikipedia.org/wiki/Robert_Griesemer) kept the syntax of Go similar to C. In late 2008 Russ Cox joined the team and helped move the language and libraries from prototype to reality.

The Go language was released in 2009 with the purpose of facilitating problem-solving in areas such as network layers, scalability, performance, productivity, and most importantly, concurrency. Rob Pike himself stated that "Go was designed to address a set of software engineering problems we faced when building large server software".

Go was influenced by various programming languages and different paradigms, including Alef, APL, BCPL, C, CSP, Limbo, Modula, Newsqueak, Oberon, occam, Pascal, Smalltalk, and Crystal. It is evident that they used the best of what they had and created something new and lean, with the minimum necessary to solve the proposed problems without losing its simplicity. I believe this can be called innovation. Go innovated by breaking the paradigms of programming languages and implementing something new in a simple and very powerful way.

Controversies

Several features that are present in other modern programming languages were deliberately left out in Go, going against the trend. These features include immutability declarations, pattern-matching data types, generics, exception handling, inheritance, method overloading, and many other points. All of these features were criticized and pointed out to the creators of Go, who responded: "These omissions were simplifications that contribute to Go's strength." There are many things in the Go language and libraries that differ from modern practices, it was a decision made by the Go development team: "Sometimes it's worth trying a different approach."

Everyone is invited to help and contribute if they wish, they can submit proposals for new features and anything related to the language's ecosystem. The Go source code is available on GitHub. The documentation on how you can contribute to the language is provided here.

Goroutines instead of threads

One of the main goals of the Go programming language is to make concurrency simpler, faster, and more efficient.

Goroutines are lightweight and take advantage of all available processing power. Goroutines exist only in the Go runtime virtual space and not in the operating system.

A goroutine is a method/function that can be executed independently along with other goroutines. Each concurrent activity in the Go language is generally called a goroutine.
One of the most relevant and important points is the work with concurrency, which innovated by breaking the traditional model of threads and its usage by creating a new model, the goroutines, in Go. Goroutines are responsible for performing asynchronous executions in Go. They are very powerful and a simple machine with 1GB of RAM could run thousands of them.

Goroutines are part of making concurrency easy to use. Goroutines can be very cheap: they have little overhead beyond memory for the stack, which is only a few kilobytes. To make stacks small, the Go runtime uses resizable and bounded stacks. A newly launched goroutine gets a few kilobytes, which is almost always enough. When it's not, the runtime increases (and shrinks) the memory to store the stack automatically, allowing many goroutines to live in a modest amount of memory. The CPU overhead averages three cheap instructions per function call. It is practical to create hundreds of thousands of goroutines in the same address space. If goroutines were just threads, system resources would run out at a much smaller number.

The design of Go was heavily influenced by C.A.R. Hoare's 1978 article "Communicating sequential processes".

Simultaneity in CSP Ideas

One of the most successful models for providing high-level language support for concurrency is Hoare's Communicating Sequential Processes or CSP. Occam and Erlang are two well-known languages that derive from CSP. Go's concurrency primitives derive from a different part of the genealogical tree whose main contribution is the powerful notion of channels as first-class objects. Experience with several earlier languages showed that the CSP model fits well into a procedural language framework.

The biggest difference between Go and the CSP model, besides syntax, is that Go models communication channels explicitly as channels, while the processes of Hoare's language send messages directly to each other, similar to Erlang.

In order to achieve this result, Go has once again received criticism for the adopted model. Go incorporates a variant of CSP (Communicating Sequential Processes), a formal language for describing interaction patterns in concurrent systems with first-class channels. A single-write approach was not adopted to enhance the semantics in the context of concurrent computing, as is done in Erlang, instead, they adopted something practical that resulted in something powerful, allowing for simple and safe concurrent programming, but does not prevent incorrect programming. And the created motto was: "Do not communicate by sharing memory, share memory by communicating". The simplicity and support for concurrency offered by Go generate robustness.

Concurrency is different from Parallelism

One of the famous phrases is: "Concurrency is about dealing with many things at once. Parallelism is doing many things at once." Concurrency is the composition of independent execution calculations. Concurrency is a way of structuring software and is definitely not parallelism, although it allows for parallelism. If you only have one processor, your program can still be concurrent, but it cannot be parallel. On the other hand, a well-written concurrent program can be efficiently executed in parallel on a multiprocessor. I suggest checking out this talk by Rob Pike, "Concurrency is not Parallelism".

Concurrency in Go is very powerful and also simple to code, which was the intention of the engineers who developed Go. Solving many problems is much more efficient using concurrency, and this is the power of Go, which is why it has become a deity when it comes to concurrency. Therefore, problems encompassed in this universe will be solved very efficiently and, most importantly, with very few computational resources.

When we talk about concurrency, we need to highlight that there are some patterns, which I describe below, and there are some types of workloads that will serve as our compass to determine our balance point when we have to solve problems involving concurrency.

Workloads: CPU-Bound & IO-Bound

A thread can perform two types of workloads (Workloads): CPU-Bound and IO-Bound.

CPU-Bound: This workload will never create a situation where the thread can be put into waiting states. It will be constantly performing calculations. A thread calculating pi to the eighteenth power would be limited by the CPU. (Fun fact: Emma Haruka Iwao is a Japanese computer scientist and cloud developer engineer at Google. In 2019, Haruka Iwao calculated the most accurate value of pi in the world, which included 31.4 trillion digits). This type of workload, CPU-bound work, requires parallelism to take advantage of concurrency. More Goroutines will not help and will not be efficient, potentially further delaying the workloads to be executed, due to the latency cost (the time spent) of moving Goroutines in and out of the operating system's thread.

IO-Bound: In this type of workload, threads enter waiting states. A good example would be a request for accessing a resource over the network or making calls to the operating system. A thread that needs to access a database, synchronization events (mutex, atomic), all of these examples make the thread wait, so we could say they are of the IO-Bound type of workload. In this type of workload, you do not need parallelism to use concurrency, a single physical core would be sufficient for the proper execution of several Goroutines. The Goroutines are entering and exiting waiting states as part of their workload. In this type of workload, having more Goroutines than physical cores can speed up execution because the latency cost of moving Goroutines in and out of the operating system's thread is not creating an event. Its workload is naturally interrupted, allowing a different Goroutine to take advantage of the same physical core instead of allowing it to remain idle.

Goroutine and Pattern

There are some patterns for concurrency, among them: Fan-In and Fan-Out.

Fan-Out: Multiple functions can read from the same channel until that channel is closed, this is called fan-out. This provides a way to distribute work among a group of workers to make use of CPU and I/O in a concurrent manner.

Fan-In: It is the way to read from multiple inputs and proceed until all of them are closed, multiplexing the input channels into a single channel that is closed when all the inputs are closed. This is called fan-in.

Pipeline: There is no formal definition of a pipeline in Go, it is just one of the many types of concurrent programs. Informally, a pipeline is a series of stages connected by channels, where each stage is a group of goroutines running the same function. At each stage, the goroutines:

• Receive values from upstream via input channels;

• Perform some function on that data, usually producing new values;

• Send values downstream via output channels.

Each stage has several input and output channels, except for the first and last stages, which have only input or output channels, respectively.

To give you an idea, on a 1 CPU and 1 GB RAM machine, we can handle 5k to 6k requests per second with a simple Go API, with few lines of code, using either RPC or native TCP protocols and writing to a relational database like PostgreSQL, without crashing it and consuming an average of only 60Mb to 70Mb of memory and 8% to 15% of CPU. To achieve this, we use a "Worker Poll" that is a Fan-out.

If you want to delve further into concurrency, you can check out this link. If you want to test and see some examples, you can click here. We'll create a separate post to talk about Goroutines, which is a very detailed and interesting topic. We know that Go's support for concurrency makes it a godsend for problems that are best solved using concurrency.

Go is a compiled language, a C-like language, very focused on productivity. For simple or complex projects, Go will always be an excellent alternative, as it makes everything simpler and leaner, easy to code and maintain.

package main

import "fmt"

func main() {
    fmt.Printf("Hello, I love Go!\n")
}

There is no silver bullet

There is no solution or tool to solve all problems yet, of course. What we know is that there are countless solutions developed in various languages, each with a purpose and each with its own characteristics. For this reason, there are programming paradigms, which is a way of classifying languages based on their functionalities, making it easier to understand the context in which they will be better inserted, and, of course, giving us a view of their structure and execution of the languages.

It is becoming increasingly common for languages to support multiple paradigms. We know that there are different classes in computing when it comes to solving problems, and the closer we are to these subjects, the more comfortable we will be to choose a certain language to solve problems, and thus know which tool to use at the right time. In practice, this task is not so easy, but what we know is that the silver bullet has not yet been created to solve all problems at once with just one language, if it existed, there would no longer be P versus NP and all problems could be solved in polynomial time.

The Good Things About Go

• It does not have generics;

• It does not have operator overloading;

• It does not have pointer arithmetic;

• Thread management is not explicitly managed;

• It has type inference;

• Dependencies are clear;

• The syntax is clean;

• The semantics are clear;

• Composition over inheritance;

• Native GC (Garbage collector);

• It has Goroutines;

• Native support for concurrent programming;

• First-class functions (we can pass functions as parameters);

• Cross-platform;

• Open Source;

• Very low learning curve, meaning it is easy to learn;

• Highly productive;

• Solves scalability problems;

• It can drastically reduce server costs;

• Various problems thought from the Go perspective become much easier to handle and solve;

• It has only 25 reserved keywords;

• Multi-paradigm: concurrent, functional, imperative, object-oriented;

• Memory Safe.

We know that various points above will be criticized, but in practice and over time, we realized that all the omitted simplifications made Go an even more powerful language.

When we didn't have Generics

When we didn't have Generics There are strong reasons why Go didn't implement Generics early in the project, and there's a discussion in the general communities about this topic. Go left out several features, including “Generics”, which in its conception would directly compromise the performance and purpose that the Go language was intended to solve.

Complainants are mainly developers who come from languages that use this feature. On November 29, 2018, the Go source code maintainers opened up the possibility to submit proposals for new features with all the details so that they can analyze them and possibly implement them in the Go 2.0 version, but we know that this happened before in March 2022 version 1.18 was released. To get a good idea, read this file by by clicking here.

In Go 1.18, the language introduced a new feature called generic types that had been on the wish list of Go developers for some time. In programming, a generic type is a type that can be used in conjunction with many other types. Normally in Go, if you want to use two different types for the same variable, you need to use a specific interface, like io.Reader, or use interface{}, which allows you to use any value. Using the {} interface can make working with these types difficult because you have to translate between several other possible types to interact with them. Using generic types allows you to interact directly with your types, leading to cleaner, easier-to-read code.

Example:

Imagine a method that receives an array of type int and prints it on the screen.
Imagine now needing to do the same with the String type and the float type, you would have to create new methods or functions several times, repeating the code.

Solution: To avoid creating several methods, only one method is created as a generic to be able to receive any type.

type iMyinterface interface {
    int | int64 | int32
    ~float64
    ~string
    ~[]byte
    MyMethod()
}

func NoGenericFuncStrs(a, b []string) bool
func NoGenericFuncInts(a, b []int) bool
func NoGenericInterface(a, b interface{}) bool

func GenericsFuncStrs[T comparable](a, b []T) bool

Note that this is only a problem in languages that need to declare types of variables or functions, etc. In dynamic languages like PHP, for example, this is not necessary. I won't say strongly or weakly typed languages because it's a bit more complex than that, and that would lead to another discussion.

In Go, we can solve all problems of this nature using reflect and other interfaces and now we have Generics to make our work even easier 😎.

Below are three examples with three proposals to solve the problem in this way, and you will be able to understand when we talk about Generics. 😊

Copying and Pasting Functions with Specific Types

package main

// Takes a slice of any type and reverses it.
func Reverses(list []string) []string {
    i := 0
    j := len(list) - 1
    for i < j {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
    return list
}

// Takes a slice of any type and reverses it.
func Reversei(list []int) []int {
    i := 0
    j := len(list) - 1
    for i < j {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
    return list
}

func main() {
    s := []string{"otoni","jeff","Go"}
    Reverses(s)
    println(s[0], s[1], s[2])

    i := []int{2020,2012,2009}    
    Reversei(i)    
    println(i[0], i[1], i[2])
}

Using Interface

package main

// Takes a slice of any type and reverses it.
func Reverse(in interface{}) interface{} {
    switch in.(type) {
        case []string:
        list := []string(in.([]string))
        i := 0
        j := len(list) - 1
        for i < j {
                list[i], list[j] = list[j], list[i]
           i++
           j--
            }
            return list

         case []int:
        list := []int(in.([]int))
        i := 0
        j := len(list) - 1
        for i < j {
           list[i], list[j] = list[j], list[i]
           i++
           j--
            }
            return list
    }
    return nil
}

func main() {
    s := []string{"otoni","jeff","Go"}
    Reverse(s)
    println(s[0], s[1], s[2])

    i := []int{2020,2012,2009}    
    Reverse(i)    
    println(i[0], i[1], i[2])
}

Using Generics

// https://go2goplay.golang.org/
package main

import (
    "fmt"
)

// The playground now supports parentheses or square brackets (only one at
// a time) for generic type and function declarations and instantiations.
// By default, parentheses are expected. To switch to square brackets,
// the first generic declaration in the source must use square brackets.

func Print[type T] (s []T){
    for _, v := range s {
        fmt.Print(v)
    }
    fmt.Println("")
}

func Reverse[type T](list []T) {
    i := 0
    j := len(list) - 1
    for i < j {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
}

func main() {
        var i []interface{}
        i = append(i, "jeffotoni")
        i = append(i, " ano de 2020 ")
        i = append(i, []string{"otoni", "jeff", "Go"})
    i = append(i, []int{2020, 2012, 2009})
        Print(i)

    s := []string{"otoni", "jeff", "Go"}
    Reverse(s)
    Print(s)

    intt := []int{2020, 2012, 2009}
    Reverse(intt)
    Print(intt)
}

Composition over Inheritance

The approach adopted by Go departs from the norm and is unusual for object-oriented programming, allowing methods of any type, not just classes, but without any form of type-based inheritance, such as subclasses. This means that there is no type hierarchy. This is not a bug, not a disadvantage, nor an error, but an intentional design choice by the developers of Go. Although type hierarchies have been used to build successful software, it is the stance and opinion of the Go development team, that they preferred to take a step back instead of doing the same repetitive model in various languages.

Interfaces are implicit

Instead, Go has interfaces, which are just a set of methods and nothing more.

Example:

go

type Geometric interface {
  area() float64
  perim() float64
}

All data types that implement these methods satisfy this interface implicitly, there is no "implements" in the declaration. Interface satisfaction is checked statically at compile time, therefore, despite the decoupling interfaces, they are type-safe.

A type usually satisfies many interfaces, each corresponding to a subset of its methods. This fluidity of interface satisfaction encourages a different approach to software construction, breaking the existing paradigm.

Why aren't interfaces explicit?

Object-oriented programming provides a powerful view: that the behavior of data can be generalized independently of the representation of that data. The model works best when a behavior (set of methods) is fixed, but once you insert a subclass into a type and add a method, the behaviors are no longer identical. If instead, the set of behaviors is fixed, as in interfaces statically defined in Go, the uniformity of behavior allows data and programs to be composed uniformly, orthogonally, and safely. Type hierarchies result in fragile code. Go stimulates composition and not inheritance, using simple interfaces, usually of one method, to define trivial behaviors that serve as clear and understandable boundaries between components and eliminating the type hierarchy also eliminates one form of dependency hierarchy. The designs are not like hierarchical methods inherited from subtypes. They are more loose, organic, decoupled, independent and therefore scalable.

go

package main

import "fmt"
import "math"

type Geometric interface {
    area() float64
    perim() float64
}

type rect struct {
    width, height float64
}

type circle struct {
    radius float64
}

func (r rect) area() float64 {
    return r.width * r.height
}

func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}

func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)
    measure(c)
}

Duck typing

Go supports "Duck typing", a typing style in which the methods and properties of an object determine the valid semantics, rather than its inheritance from a particular class or implementation of an explicit interface. The concept's name refers to the duck test, attributed to James Whitcomb Riley. This makes Go look like a dynamic language.

Go uses "Structural Typing" in methods to determine the compatibility of a type with an interface. There are no type hierarchies, and "Structural Typing" is an interesting alternative to classic inheritance in statically typed languages. It allows you to write generic algorithms without obscuring the definition of a type in a sea of interfaces. Perhaps more importantly, it helps statically typed languages capture the feel and productivity of dynamically typed languages.

"Duck typing" occurs at runtime and "Structural Typing" occurs at compile time. Go does not support object orientation as implemented in languages like C#, Java, or even C++, it has no inheritance and honestly, I am very happy with this, but it does offer some features such as composition and interfaces.

go

package main

import (
    "fmt"
)

type family interface {
    dados() string
}

type pai struct {
    Nome  string
    Idade int
    Cpf   string `json:"campo-x"`
}

func (p pai) dados() string {
    return fmt.Sprintf("Nome: %s, Idade: %d", p.Nome, p.Idade)
}

type filho struct {
    pai
    email string
}

func (f filho) dados() string {
    return fmt.Sprintf("Nome: %s, Idade: %d, Email: %s", f.Nome, f.Idade, f.email)
}

func mostraDados(membro familia) {
    fmt.Println(membro.dados())
}
func main() {
    pai := new(pai)
    pai.Nome = "Jeff"
    pai.Idade = 50
    pai.Cpf = "00.xxx.xxx-xx"

    filho := new(filho)
    filho.Nome = "Arthur"
    filho.Idade = 20
    filho.email = "arthur@gmail.com"

    mostraDados(pai)
    mostraDados(filho)
 }

Strong third-party library support

In the current scenario, Go has taken off as a programming language and all major, medium, and small existing players are developing their libraries, SDKs, clients, etc. in the Go language. There are thousands of initiatives and many third-party libraries. Everything contributes to this, the Go community is very strong, it grows every day, it has a very high acceptance curve, and with this, it facilitates its entry into companies and its use by developers.

The result of this is mass dissemination on the internet with libraries written in Go. There are also libraries that are abandoned, as in any other language, but functional. But the number of libraries written in Go is very, very large. Several companies are rewriting their platforms in Go, which is a trend that continues to grow. And day by day the number of tools for DevOps grows, and with this, the acceptance and increase of new adherents to Go grows in the DevOps culture and community.

After the implementation of version control VGO in Go, we now have the possibility of not needing our projects to be under $GOPATH, we can now create our projects in any directory outside $GOPATH. This feature is only possible due to version control, when we use "go mod" our project workspaces are controlled in a new way, just run the command "go mod init yourapp" and a file named "go.mod" will be created containing the location of your path and the version in which it is located. Very simple and beautiful. Every time we run our Go project, we can use the environment variable "GO111MODULE=yes|no" to determine whether we will use "go mod" or not.

Garbage collector (GC)

GCs are complex pieces of software, decades of research and implementations, and various attempts by computer scientists to make an improved and reliable GC. It is not a simple task, and due to this, there is a huge chain on the internet describing the pros and cons of a GC. What we have to take into consideration is that regardless of the result, if we didn't have a GC, we would have to build one to solve the allocation problem.

There are usually two ways to allocate memory in Go: on the stack and on the heap. Generally, developers are familiar with the stack, just write a recursive program and you will notice a stack overflow if you don't do it correctly. The heap, on the other hand, is a pool of memory that can be used for dynamic allocation.

Stack allocations are great because they only live during the lifetime of the function to which they belong. Heap allocations, however, will not be deallocated automatically when they go out of scope. To avoid the heap becoming dissociated, we must deallocate it explicitly or, in the case of memory-managed programming languages (like Go), rely on the garbage collector to locate and delete unreferenced objects.

In general, in languages with a GC, the more you can store on the stack, the better, since these allocations are never seen by the GC. Compilers use a technique called escape analysis to determine whether something can be allocated on the stack or should be placed on the heap.

In practice, writing programs that force the compiler to allocate only on the stack can be very limiting, and thus, in Go, we take advantage of its wonderful GC to do the work of keeping our heap clean.

If you want to take a look and delve deeper into the subject, check out this link written by Richard L. Hudson: https://blog.golang.org/ismmkeynote.

Some types of applications implemented in Go

Go is a general-purpose language. In this link, you can see various applications implemented in Go and their respective categories.

Some types:

. Web backend (with various frameworks available)
. Web Assembly (one of them is vugu framework)
. Microservices (some frameworks: Go Micro, Go Kit, Gizmo, Kite)
. Fragments services (Term mentioned by @jeffotoni in a microservices discussion group)
. Lambdas (FaaS example)
. Client Server
. Terminal applications (using the tview lib)
. IoT (some frameworks)
. Bots (some here)
. Client Applications using Web technology
. Desktop using Qt+QML, Native Win Lib (example Qt, Qt widgets, Qml)
. Network Applications
. Protocol applications
. REST Applications
. SOAP Applications
. GraphQL Applications
. RPC Applications
. TCP Applications
. gRPC Applications
. WebSocket Applications
. GopherJS (compiles Go to JavaScript)

Sabemos que a Linguagem Go é um Like C e também sabemos que a linguagem Go teve influências de diversas outras linguagens de programação e paradigmas diferentes, dentre elas: Alef, APL, BCPL, C, CSP, Limbo, Modula, Newsqueak, Oberon, occam,Pascal, Smalltalk e Cristal. Como podem perceber temos uma miscelânea de paradigmas porém o paradigma Imperativo e Concorrente são os que mais predominam em Go.

Go é uma linguagem orientada a objetos a resposta para esta pergunta é SIM e NÃO 😱. No site oficial Go em faq encontraremos alguns pontos sobre isto caso queira da uma conferida só clicar em: Go Object Oriented Language

Em Go conseguimos desenvolver um estilo de programação orientada a objetos permitindo construir tipos e métodos porém não há hierarquia de tipos, é bem diferente da implementação que conhecemos em outras linguagens de programação porque não temos um arsenal de recursos como Linguagens desenvolvidas para o paradigma orientadas a objetos. O que temos em Go é uma abstração para flexibilizar e ajudar quando precisarmos utilizar diferentes tipos de structs sem nos preocupar qual struct estará sendo utilizada e o mais legal deixa encapsulado seu método de forma segura.

Bem para que isto seja possível em Go temos um coadjuvante que se chama “interface” 💪🏼 ou seja “type MyInterface interface{ ... }” e sua abordagem como dissemos é diferente das implementações que conhecemos em outras langs, interface é a única forma de permitir o despacho de métodos dinâmicos em Go.

Então o que temos até o momento é uma forma de fazer polimorfismo utilizando "interface", encapsulamento de métodos e disponibiliza-los de forma dinâmica tudo isto é muito semelhante ao "Duck typing".

O Go suporta “Duck typing”, é um estilo de tipagem em que os métodos e propriedades de um objeto determinam a semântica válida, em vez de sua herança de uma classe particular ou implementação de uma interface explicita. O nome do conceito refere-se ao teste do pato, atribuído à James Whitcomb Riley. Isso faz com que o Go se pareça com uma linguagem dinâmica.

Go usa “Tipagem Estrutural“ em métodos para determinar a compatibilidade de um tipo com uma interface. Não há hierarquias de tipos e a “Tipagem Estrutural” é uma alternativa interessante à herança clássica em linguagens com tipagem estática. Ele permite que você escreva algoritmos genéricos sem obscurecer a definição de um tipo em um mar de interfaces. Talvez mais importante, ajuda as linguagens com tipagem estática a capturar a sensação e a produtividade das linguagens dinamicamente tipificadas.

“Duck typing” ocorre em tempo de execução e “Tipagem Estrutural” que ocorre em tempo de compilação. Go não da suporte a orientação a objetos como é implementado nas linguagens como C#, Java ou mesmo C ++, não possui herança e honestamente fico muito feliz com isto, mas oferece alguns recursos como composição e interfaces como descrevemos acima.

O exemplo abaixo demostra o comportamento do que seria "Dunk typing" e polimorfismo utilizando Go.

Confira o exemplo completinho aqui: https://play.golang.org/p/C3VbgbVQnhs

A interface é uma coleção de métodos, além de ser um tipo personalizado.

Dizemos que algo satisfaz esta interface (ou implementa esta interface ) se tiver um método com a assinatura exata Dados() string.

Por exemplo, a struct Pai satisfaz a interface porque tem um Dados() string definido como método.

Não é realmente importante o que esse "Pai" é ou faz. A única coisa que importa é que tem um método chamado Dados() que retorna uma string.

Ou, como Filhos, o tipo a seguir também satisfaz a "interface Familia" - novamente porque tem um método com a assinatura exata Dados() string.

O importante aqui é que temos três tipos diferentes Pai, Filho e Filhos, que fazem coisas diferentes. Mas o que eles têm em comum é que ambos satisfazem a "interface Familia".

Podemos pensar sobre isto de outra maneira. Se você sabe que um objeto satisfaz a "interface Familia", pode confiar que ele tem um método com a assinatura exata Dados() string que pode ser chamada.

Agora vamos conferir nossa função "showDados(...)" que será responsável por acessar todos nossos métodos diferentes atendendo a mesma interface, agora você poderá usar objetos de qualquer tipo desde que satisfaça a interface.

Olha o exemplo abaixo, temos vários tipos de objetos sendo passado para a função showDados(...).

As possibilidades são diversas, podemos definir uma interface recebendo outra interface, podemos criar outras funções que satisfaça a interface como o exemplo abaixo:

A função showDados2(f []Familia) recebe um vetor da "interface Familia".

Simples não é ? Com esta definição temos diversas possibilidades que poderá utilizar "interface" em seus projetos. Clean Architecture é um bom exemplo desta utilização também, toda sua arquitetura se baseia-se em interfaces caso queiram da uma conferida clean architecture e clean architecture 2 years later

Existem alguns motivos pelos quais você poderia usar interface em Go, vou listar os três mais comuns:

- Para ajudar a reduzir a duplicação ou código padrão.

- Para tornar mais fácil usar mocks em vez de objetos reais em testes de unidade.

- Como uma ferramenta de arquitetura, para ajudar a impor o desacoplamento entre as partes de sua base de código.

Algumas interfaces utilizada em Go em sua strand libray default

Uma pequena lista de algumas das interfaces mais comuns e úteis na biblioteca padrão.

• builtin.Error

• fmt.Stringer

• io.Reader

• io.Writer

• io.ReadWriteCloser

• http.ResponseWriter

• http.Handler

• Sort

Vamos da uma olhada no pkg sort

Um tipo, normalmente uma coleção, que satisfaz a classificação. A interface pode ser classificada pelas funções neste pacote. Os métodos requerem que os elementos da coleção sejam enumerados por um índice inteiro.

O que vemos logo abaixo são as assinaturas que a interface Sort possui

o formos usar a interface iremos ter que criar os três métodos que satisfaça exatamente a Interface, e o que muda sempre são os tipos e structs que poderão implementar osmétodos que satisfaça a interface como aprendemos.

A desvantagem aqui é que não necessariamente precisaria dos três métodos para Ordenar minha struct precisaria somente do Less(…), porém somos obrigados a satisfazer a interface exatamente como ele está assinada ou seja precisaremos sempre implementar Less(…), Len(…), Swap(…).

Como boa prática sempre é interessante termos interfaces mais enxutas possíveis.

Uma curiosidade aqui neste pkg é a possibilidade de utilizar uma interface incorporada e que o Reverse use os métodos de implementação de outra interface 😱.

Legal não é ? Ou seja o Less(...) retorna o oposto do método Less(...) da implementação incorporada.

E para fechar temos diversos tipos diferentes criando e implementando seus próprios métodos Less(…), Len() e Swap(..)

Este post está escrito em varias plataformas e existe uma versão mais completa que escrevi que encontra-se neste link Go é Orientado a Objeto ?

Não tinha como não descrever algumas possibilidades e não aguentei de despejei o que consegui neste post, desculpem pelo tamanho do post.

Aqui uma lista completa de interfaces em Go

Lista completa de interface Go

Caso queiram acessar o código fonte do exemplo apresentado

Código fonte

Conclusão

Espero que tenha gostado do resumo e uma breve introdução do que podemos fazer em Go quando o assunto é Orientação a Objeto. Qualquer observação, dica, melhoria etc.. no conteúdo por favor só enviar para melhora-lo ainda mais.

Uma forma que a equipe de Go encontrou para melhorar ainda mais seu processo evolutivo da linguagem foi experimentando e colocando em prática a própria linguagem. Russ Cox descreveu: "Utilizamos e experimentamos o Go como ele existe agora, para entende-lo melhor, aprender o que funciona bem e o que não funciona. Então, experimentamos possíveis mudanças, para entendê-las melhor, novamente aprendendo o que funciona bem e o que não funciona. Com base no que aprendemos com esses experimentos, simplificamos. E então nós experimentamos novamente. E então nós simplificamos novamente. E assim por diante. E assim por diante."

Os quatro R's da simplificações

Durante esse processo, a equipe de desenvolvimento Go apresentou quatro maneiras principais de simplificar a experiência geral de escrever programas Go: remodelando, redefinindo, removendo e restringindo.

Simplifique remodelando

A primeira maneira que simplificamos é reformular o que existe em uma nova forma, que acaba sendo mais simples no geral.

Cada programa Go que escrevemos serve como uma experiência para testar o próprio Go. Nos primeiros dias do Go, nota-se que aprendem rapidamente a escrever código como essa addToList:

func addToList(list []int, x int) []int {
    n := len(list)
    if n+1 > cap(list) {
        big := make([]int, n, (n+5)*2)
        copy(big, list)
        list = big
    }
    list = list[:n+1]
    list[n] = x    
    return list

}

Basta conferir o código que percebe-se que escreveria o mesmo código para slices de bytes e slices de strings, e assim por diante. Estes programas eram muito complexos, porque o Go era muito simples.

Então, a equipe que desenvolve Go pegou as muitas funções, como addToList, e as transformou em uma função fornecida pelo próprio Go. A adição append tornou a linguagem Go um pouco mais complexa, mas, no geral, tornou a experiência geral de escrever programas Go mais simples, mesmo depois de contabilizar o custo do aprendizado append.

Adicionaram código e complexidade à distribuição Go, mas no final simplificamos a experiência de escrever programas Go. A nova estrutura também criou espaço para outros experimentos interessantes, que veremos mais adiante.

Simplifique redefinindo

Uma segunda maneira que eles encontraram para simplificar é redefinir a funcionalidade que já temos, permitindo que ela faça mais. Como simplificar remodelando, simplificar redefinindo torna os programas mais simples de escrever, mas agora sem nada de novo para aprender.

Por exemplo, append foi originalmente definido para ler somente slices. Ao anexar a uma slice de byte, você poderia acrescentar os bytes de outra slice de byte, mas não os bytes de uma string. Nós redefinimos acrescentar para permitir acrescentar uma string, sem adicionar nada de novo ao idioma.

var b []byte
var more []byte
b = append(b, more...) // ok


var b []byte
var more string
b = append(b, more...) // ok later

Simplifique Removendo

Uma terceira maneira que encontraram para simplificar é removendo a funcionalidade quando ela se tornou menos útil ou menos importante do que esperavam. Remover a funcionalidade significa menos uma coisa para aprender, uma coisa a menos para corrigir erros, uma coisa a menos para se distrair ou usar incorretamente. Evidentemente, a remoção também força os usuários a atualizar os programas existentes, talvez tornando-os mais complexos, para compensar a remoção. Mas o resultado geral ainda pode ser que o processo de escrever programas Go se torne mais simples.

Um exemplo disso é quando removeram as formas booleanas de operações de canal sem bloqueio do idioma:

ok := c <- x  // before Go 1, was non-blocking send
x, ok := <-c  // before Go 1, was non-blocking receive

Essas operações também foram possíveis de usar select, tornando confuso precisar decidir qual forma usar. Removê-los simplificou a linguagem sem reduzir seu poder.

Simplifique restringindo

Também perceberam outra forma de simplificar restringindo o que é permitido. Desde o primeiro dia, o Go restringiu a codificação dos arquivos-fonte do Go: eles devem ser o UTF-8. Essa restrição faz com que todo programa que tenta ler os arquivos de origem do Go seja mais simples. Esses programas não precisam se preocupar com arquivos de código-fonte Go codificados em Latin-1 ou UTF-16 ou UTF-7 ou qualquer outra coisa.

Outra restrição importante é gofmt para formatação do programa. Nada rejeita o código Go que não é formatado usando gofmt, mas nós estabelecemos uma convenção de que as ferramentas que reescrevem os programas Go as deixam em gofmt. Se você mantiver seus programas em gofmt também, eles não farão nenhuma alteração de formatação. Quando você compara antes e depois, os únicos diffs que você vê são mudanças reais. Esta restrição simplificou reescrever e levou a experiências bem sucedidas, como goimports, gorename, e muitos outros.

Processo de desenvolvimento Go

Este ciclo de experiência e simplificação é um bom modelo que os integrantes da equipe de desenvolvimento do Go tem feito nos últimos dez anos. mas tem um problema: é simples demais. Não contiveram em apenas experimentar e simplificar.

Tiveram que enviar os resultados, disponibilizá-los para usar. É claro que usá-lo permite mais experimentos e, possivelmente, mais simplificação, e o processo avança e continua.

Go foi liberado para todos pela primeira vez em 10 de novembro de 2009. Então, com ajuda de todos da comunidade, enviaram Go 1.0 em março de 2012. E já lançaram doze lançamentos Go desde então. Todos esses foram marcos importantes, para permitir mais experimentações, toda comunidade colaborou e ajudou a aprender mais sobre o Go e, é claro, para disponibilizar o Go para uso em produção.

Quando lançaram o Go 1, explicitamente mudaram internamente toda equipe que desenvolveu Go o foco para o uso do Go, para que conseguissem entender melhor a versão da linguagem antes de tentar mais simplificações envolvendo alterações de idioma. Precisavam de um tempo para experimentar, para realmente entender o que funciona e o que não funciona.

Eles estão o tempo todo testando e experimentando, simplificando e atualizando novas versões. Estão bem mais concentrados em maneiras de simplificar o desenvolvimento do Go sem alterações significativas na linguagem e sem interromper os programas existentes do Go. Por exemplo, o Go 1.5 tivemos o primeiro coletor de lixo (GC) simultâneo e, em seguida, os seguintes releases o aprimoraram, simplificando o desenvolvimento do Go, removendo os tempos de pausa como uma preocupação constante.

Na Gophercon em 2017, anunciaram que após cinco anos de experimentação, era hora de pensar novamente em mudanças significativas que simplificariam o desenvolvimento do Go. O caminho para o Go 2 é realmente o mesmo que o caminho para o Go 1: experimentar e simplificar e liberar, em direção a um objetivo geral de simplificar o desenvolvimento do Go.

Para o Go 2, os tópicos concretos que eles consideram mais importantes e o que são abordados nos posts são: manipulação de erros, generics e dependências. Desde então, percebe-se que outro tópico importante é o desenvolvimento de ferramentas.

Conclusão

Foi apresentando um pouco do ciclo de desenvolvimento que a equipe responsável por manter a linguagem Go fazem, isto é explícito para toda comunidade. Toda evolução da linguagem é comunicada pela equipe e abrem um canal de comunicação direto com a comunidade e isto vem dando certo, diversas propostas são lançadas e discutidas a fundo, isto é muito legal e muito positivo. A linguagem cresce dia após dia tornando-se cada vez mais popular e poderosa. O mais bacana de tudo é que não estão preocupados com funcionalidades surrealistas ou apenas para agradar um público específico, eles estão caminhando um passo de cada vez, mantendo o designer inicial que a linguagem propunha, e focando no que realmente importa que é cada vez mais torna a linguagem simples para os que forem desenvolver em Go. Neste cenário percebe-se claramente que no designer de Go "Menos é exponencialmente Mais" a equipe de desenvolvedores do Go dizem que sua criação é uma tentativa de tornar os programadores mais produtivos e estão cada vez mais próximo deste objetivo. Os caminhos para o Go 2.0 são os mesmos que utilizaram até o momento e o foco será manipulação de erros, generics e dependências.

Quando falamos de concorrência temos que ressaltar que existe alguns tipos de cargas de trabalhos eles serão nossa bússola para determinar nosso ponto de equilíbrio quando tivermos que resolver problemas evolvendo concorrência.

Uma thread pode fazer dois tipos de cargas de trabalhos (Workloads): CPU-Bound e o IO-Bound.

CPU-BOUND

Esta carga de trabalho nunca irá cria uma situação em que a thread pode ser colocado em estados de espera. Ele estará constantemente fazendo cálculos. Uma thread calculando pi para décima oitava potência seria limitado pela CPU. (curiosidade: Emma Haruka Iwao é uma cientista da computação japonesa e Engenheira de Desenvolvimento Cloud do Google. Em 2019, Haruka Iwao calculou o valor de pi mais preciso do mundo, que incluiu 31,4 trilhões de dígitos).

Este tipo de carga de trabalho, trabalhos ligadas à CPU, você precisa do paralelismo para aproveitar a simultaneidade, mais Goroutines não irá ajuda-lo e não serão eficientes, podendo atrasar ainda mais as cargas de trabalho a serem executadas, isto ocorre devido ao custo de latência (o tempo gasto) de mover Goroutines dentro e fora da thread do sistema operacional

IO-BOUND

Neste tipo de carga de trabalho as threads entram em estados de espera. Um bom exemplo seria uma solicitação de acesso a um recurso pela rede ou fazer chamadas para o sistema operacional. Uma thread que precisa acessar um banco de dados, eventos de sincronização (mutex, atomic), todos estes exemplos fazem com que a thread aguarde então poderíamos dizer que são do tipo de trabalho IO-Bound. Neste tipo de carga de trabalho você não precisa de paralelismo para usar a simultaneidade um único core físico já seria suficiente para uma boa execução de várias Goroutines. As Goroutines estão entrando e saindo dos estados de espera como parte de sua carga de trabalho.

Neste tipo de carga de trabalho ter mais Goroutines do que cores físicos pode acelerar a execução porque o custo de latência de mover Goroutines dentro e fora do thread do sistema operacional não está criando um evento. Sua carga de trabalho é naturalmente interrompida e isso permite que uma Goroutine diferente aproveite o mesmo core físico ao invés de permitir que ele fique ocioso.

CONCLUSÃO

Desta forma saberemos quando usar mais cores físicos de forma paralelos ou quando iremos precisar somente utilizar concorrência com poucos cores físicos ou somente um core. Em Go os patterns que irão nos ajudar a equilibrar esta equação, existirá momentos que precisaremos de ambos os recursos de carga de trabalho. Quer aprofundar um pouco mais sobre o assunto basta clicar neste link (Simplificando a complexidade “O Inicio”) onde tem um post bem completo.

Problema a ser resolvido

Temos que abrir uma conexão com o banco de dados e mantê-la em uma única instância para não sobrecarregar o banco e termos problemas ou erros com o limite de conexões simultâneas excedido, além, é claro, de otimizarmos nosso código. Sabemos que uma conexão é muito custosa computacionalmente.

Como o banco não dá suporte à pool de conexões de forma nativa, então precisaremos controlar todas as conexões que nossa aplicação irá abrir para se comunicar com ele, assim, em cada ação que formos executar, seja um select, delete, insert ou update, precisaremos de um objeto de conexão em memória de forma atômica e para isso vamos utilizar o pattern singleton.

Antes de implementarmos nossa solução usando Pattern Singleton para resolver o problema do pool de conexões, vamos conferir alguns outros exemplos da necessidade da utilização do pattern singleton.

Abaixo alguns exemplos de diversas formas de tentar proteger nossa variável global.

Protegendo variável Global Exemplo 1

// type global
type singleton map[string]string

var (
    instance singleton
)

func NewClass() singleton {

    if instance == nil {

        instance = make(singleton) // <-- not thread safe
    }

    return instance
}

Protegendo variável Global Exemplo 2

var lock = &sync.Mutex{}

// type global
type singleton map[string]string

var (
    instance singleton
)

func NewClass() singleton {

    lock.Lock()
    defer lock.Unlock()

    if instance == nil {

        instance = make(singleton) // <-- thread safe
    }

    return instance
}

Protegendo variável Global Exemplo 3

var once sync.Once

// type global
type singleton map[string]string

var (
    instance singleton
)

func NewClass() singleton {

    once.Do(func() { // <-- atomic, does not allow repeating

        instance = make(singleton) // <-- thread safe

    })

    return instance
}

Acima é mostrado três formas de proteger nossa variável global “instance”, para soluções síncronas o exemplo 1 já irá funcionar, para soluções assíncronas o exemplo 2 e 3 são o mais indicados sendo que o exemplo 3 é a melhor solução para protegermos de “race condition” garantindo que a instância seja declarada uma única vez tornando-se atômica.

O objetivo do artigo é mostrar exatamente as formas de tentar proteger a variável global, em Golang temos diversas maneiras de fazermos isso.
Abaixo temos mais alguns exemplos para complementar o raciocínio, mostrando como fazemos as instanciações do nosso singleton, seja ele de forma síncrona ou assíncrona usando goroutine.

Exemplos de como instanciar nosso Singleton

O código abaixo é um bom exemplo de aberturas de diversas conexões de forma síncrona, dependendo da forma que implementarmos nossa instância de conexão o banco não suportaria.

func main() {

    objeto := NewClass() // instance make

    objeto["this"] = "Object NewClass"
    objeto2 := NewClass() // return instance

    fmt.Println("This is:", objeto2["this"])

    objeto3 := NewClass() // return instance
    objeto4 := NewClass() // return instance
    objeto5 := NewClass() // return instance

    fmt.Println("This is:", objeto3["this"])
    fmt.Println("This is:", objeto4["this"])
    fmt.Println("This is:", objeto5["this"])
}

Agora vamos visualizar um exemplo de abertura de conexões de forma assíncrona utilizando goroutine. Fizemos centenas de goroutines e milhares de conexões simultâneas em nosso exemplo abaixo, funciona 100% sem travar e ou bugar a quantidade de conexões do banco de dados.

func main() {

    objeto := NewClass() // instance make

    go func() {

        for i := 0; i < 1000; i++ {

            objeto = NewClass() // <-- return instance
        }
    }()

    go func() {

        for i := 0; i < 100; i++ {

            go func() {

                objeto = NewClass() // <-- return instance
            }()
        }
    }()

    fmt.Scanln()
}

Goroutines e o pattern singleton

Quando pensamos nas possíveis soluções para a implementação do pattern singleton usando Golang, esbarramos nos Goroutines ele será responsável por nos proporcionar que nosso código execute de forma assíncrona e concorrente e quando usamos Goroutine em nossa aplicação toda nossa forma de pensar e implementar muda, ou seja não é mais uma aplicação síncrona e devido a isso temos que pensar da forma Golang de ser.

As Goroutines é um poderoso recurso e quando usado corretamente ele torna-se um forte aliado para combatermos as batalhas do dia a dia. Toda vez que implementamos códigos que usam concorrência temos alguns cenários já conhecidos que temos que tratar, o escopo do programa, variáveis globais, locais, passagem de parâmetros, ponteiros tudo isso tem que ser tratado para que possamos trabalhar com concorrência de forma correta e otimizada.

Um bom exemplo de possíveis problemas usando concorrência é a utilização de variáveis globais. Devido as goroutines nossa implementação do Pattern Singleton e nossas possíveis soluções será escrita para aceitar o uso de concorrência. Vamos escrever o nosso código usando boas práticas de programação, para tentar mitigar os possíveis bugs sigilosos que podem ocorrer em tempo de execução do seu programa escrito em Golang.

200 goroutines sendo inicializadas

Em nosso exemplo abaixo está sendo criado 200 goroutines e colocando todas em concorrência e dez mil interações estão sendo feitas em nosso banco de dados ou seja “connect e faça: select email from login where id =?”.

    for x := 0; x < 200; x++ {

        go func(x int) {

            for j := 0; j < 10000; j++ {

                fmt.Println(" login: ", Conn.Connet().GetUserEmail(x))
                time.Sleep(time.Millisecond * 150)
            }
        }(x)
    }

O bom entendimento sobre as goroutines irá nos ajudar a escrever códigos melhores e mais poderosos em Golang, isto não tenho dúvidas. Em um próximo artigo iremos descrever alguns cases usando goroutines, estou ansioso para escrever sobre Goroutines e mostrar como resolvemos alguns de nossos problemas na empresa.

O assunto sobre Pattern Singleton é tão interessante que tive que fazer uma pesquisa bem mais profunda sobre o assunto antes de escrever este artigo e como uso muito em meu dia a dia decidi colaborar um pouco mostrando alguns pontos importantes deste pattern e por que muita das vezes ele é considerado um Anti Pattern. Descrevendo os detalhes técnicos no artigo percebemos claramente diversas boas práticas que poderemos utilizar em nosso dia dia quando estamos codando em Golang, boas práticas, formas clean de implementação, implementações menos complexas e menos custosas e com maior desempenho.

O que é Pattern Singleton?

A transcrição do que é um Pattern Singleton seria: *“*Singleton *é um padrão de projeto de software. Este padrão garante a existência de apenas uma instância de uma classe, mantendo um ponto global de acesso ao seu objeto”.*Singleton é um padrão de design que restringe a instanciação a um objeto, temos que garantir que isto ocorra somente uma única vez.

Basicamente singleton é uma maneira de usar variáveis ​​globais. Sabemos o quanto é perigoso o uso de variáveis globais, nosso código fica vulnerável ao acesso da variável global ou seja em qualquer parte do sistema podemos alterar seu valor. Portanto, ao tentarmos debugar ou depurar nosso programa não será uma tarefa fácil descobrir qual caminho de código leva ao estado atual, este é um dos motivos que não considero o Pattern Singleton um Anti Pattern e sim uma formas de proteger as variáveis globais.

No entanto, o problema com Singleton usando concorrência que será nosso objetivo, em um ambiente multiencadeado, a inicialização deve ser protegida para evitar a reinicialização, de forma atômica.

O Pattern Singleton é uma característica proveniente do paradigma orientado a objeto, então como iremos implementar em Golang se o mesmo não possui suporte a OO ?

Para responder esta pergunta temos que entender que a Programação Orientada a Objeto é um conceito e pode ser implementando em qualquer linguagem de programação mesmo sendo de outros paradigmas. É claro que o nível de abstração e dificuldade torna-se uma tarefa árdua aumentando muito o nível de complexidade do código dependendo da linguagem, nossa intenção é puramente didática com intuito de entendermos melhor o cenário proposto quando falamos em pattern singleton*.*

go run -race singleton.go

Executa todos os códigos usando -race como parâmetro: go run -race ..

O “-race detector” é um recurso que temos disponível em Golang para detectar acessos indevidos em memória quando estamos usando concorrência em nossa aplicação. É possível gerar relatório que contém rastreamentos de pilha para acessos conflitantes, bem como pilhas nas quais as goroutines envolvidas foram criadas, em breve vou criar um artigo abordando exatamente este assunto e vamos falar sobre “Profiling“ em Go.
Abaixo as formas que podemos fazer a chamada do “-race”.

$ go test -race seupkg    // to test the package
$ go run -race seusrc.go  // to run the source file
$ go build -race seucmd   // to build the command
$ go install -race seupkg // to install the package

Pattern Singleton em Golang

A solução apresentada abaixo seria ideal se nossa aplicação fosse síncrona, e o problema seria resolvido com código abaixo, mas como nosso objetivo é implementar usando concorrência a solução abaixo está longe de ser a ideal.
Vamos conferir o código abaixo e iniciar nossas possibilidades de implementação:

type DriverPg struct {
    conn string
}

var instance *DriverPg

func Connect() *DriverPg {

    if instance == nil {
        // <--- NOT THREAD SAFE / Quando usarmos Goroutine
        instance = &DriverPg{conn: "DriverConnectPostgres"}
    }

    return instance
}

func main() {

    // chamada
    go func() {

        for i := 0; i < 100; i++ {
            time.Sleep(time.Millisecond * 600)
            fmt.Println(*Connect(), " - ", i)
        }
    }()

    go func() {

        fmt.Println(*Connect())
    }()

    fmt.Scanln()
}

Na implementação acima, temos nossa primeira abordagem implementando Singleton em Golang e com goroutines para executar simultaneamente o nosso Singleton.

O problema visível neste código é que várias rotinas de goroutine poderiam avaliar a primeira verificação e todas criariam uma instância do tipo singleton e substituiriam uma à outra. Não há garantia de qual instância será retornada no código acima, e outras operações adicionais na instância podem ser inconsistentes com as expectativas do desenvolvedor e problemas sigilosos podem ocorrer em tempo de execução.

Muito ruim esta abordagem, diversos erros muitos sutis podem ocorrer, se as referências à instância singleton estiverem sendo mantidas por meio do código, existe uma grande chance de haver potencialmente várias instâncias do tipo com estados diferentes, gerando potenciais comportamentos de código. Ele também se torna um verdadeiro pesadelo durante a depuração e se torna realmente difícil detectar o bug, já que no tempo de depuração nada parece estar errado devido às pausas de tempo de execução, minimizando o potencial de uma execução “Not Thread Safe”, ofuscando totalmente o problema para quem está codando.

Bloqueios com Mutex

No código abaixo é uma solução pobre para a tentativa de resolver o problema de “Thread Safe”. Na verdade, isso resolve o problema “Thread Safe”, mas cria outros problemas sérios em potencial. Ele introduz uma contenção nas goroutines executando um bloqueio agressivo de toda a função, vamos conferir o código abaixo:

// nosso lock mutex
var lock = &sync.Mutex{}

type DriverPg struct {
    conn string
}

var instance *DriverPg

func Connect() *DriverPg {
    // <--- Desnecessario a lock
    // se a instancia já tiver
    // sido criada muito agressivo
    lock.Lock()
    defer lock.Unlock()

    if instance == nil {
        // ainda não é a melhor implementação devido
        // os bloqueios
        instance = &DriverPg{conn: "DriverConnectPostgres"}
    }

    return instance
}

func main() {

    go func() {
        for i := 0; i < 100; i++ {
            time.Sleep(time.Millisecond * 600)
            fmt.Println(*Connect(), " - ", i)
        }
    }()

    go func() {
        fmt.Println(*Connect())
    }()

    fmt.Scanln()
}

O problema de “Thread Safe” foi resolvido com a implementação acima usando sync.Mutex onde ocorre o Bloqueio antes de criar a instância Singleton. O grande problema desta abordagem é o bloqueio excessivo mesmo quando não seria necessário fazer isso, no caso de a instância já ter sido criada e deveríamos simplesmente ter retornado a instância singleton. Se nosso programa for escrito para tornar-se altamente concorrente, isso pode gerar um gargalo, pois somente uma rotina de goroutine pode obter a instância singleton de cada vez, tornando-se nossa solução mais lenta.

Vamos conferir outra solução, por que está acima não é nossa melhor abordagem.

Check-Lock-Check em Go

Um forma de melhorar e a segurar a garantia de um mínimo de bloqueio e ainda ser seguro para a goroutine é utilizar o padrão chamado “Check-Lock-Check*”*, ao adquirir bloqueios. Usamos este mesmo Patter em C e C++.
O padrão funciona com a ideia de verificar primeiro, para minimizar qualquer bloqueio agressivo, já que uma instrução IF é menos dispendiosa do que o bloqueio.

No próximo momento teríamos de esperar e adquirir o bloqueio exclusivo para que apenas uma execução esteja dentro desse bloco em uma única vez. Com a primeira verificação e com bloqueio exclusivo, poderia haver outra goroutine que adquiriu o bloqueio, portanto, precisaríamos verificar novamente dentro do bloqueio para evitar a substituição da instância por outro.

Confira o código abaixo:

var lock = &sync.Mutex{}

type DriverPg struct {
    conn string
}

var instance *DriverPg

func Connect() *DriverPg {

    // ainda não está perfeita, não é totalmente atomico
    if instance == nil {
        lock.Lock()
        defer lock.Unlock()
        instance = &DriverPg{conn: "DriverConnectPostgres"}
    }
    return instance
}

func main() {

    go func() {

        for i := 0; i < 100; i++ {
            time.Sleep(time.Millisecond * 600)
            fmt.Println(*Connect(), " - ", i)
        }
    }()

    go func() {

        fmt.Println(*Connect())
    }()

    fmt.Scanln()
}

Está abordagem acima é a melhor até o momento, mas ainda não é perfeita. Não há uma verificação atômica no estado de armazenamento da instância. Levando em consideração todas as considerações técnicas, isso ainda não é perfeito. Mas é muito melhor que as abordagens iniciais.

Usando o pacote sync/atomic, podemos carregar e definir de forma atômica um sinalizador que indicará se inicializamos ou não nossa instância.

Confira o código abaixo:

// manter o estado
var atomicinz uint64

// lock mutex
var lock = &sync.Mutex{}

// driver
type DriverPg struct {
    conn string
}

// instancia Global
var instance *DriverPg

// funcao retornando
// o ponteiro de nossa
// struct
func Connect() *DriverPg {

    // garantindo que já entrou
    if atomic.LoadUint64(&atomicinz) == 1 {

        return instance
    }

    lock.Lock()
    defer lock.Unlock()

    // entra somente uma
    // únic vez
    if atomicinz == 0 {

        instance = &DriverPg{conn: "DriverConnectPostgres"}
        atomic.StoreUint64(&atomicinz, 1)
    }

    return instance
}

func main() {

    // chamada
    go func() {
        time.Sleep(time.Millisecond * 600)
        fmt.Println(*Connect())
    }()

    // 50 goroutine
    for i := 0; i < 50; i++ {
        go func(i int) {
            for {
                time.Sleep(time.Millisecond * 60)
                fmt.Println(Connect().conn, " - ", i)
            }
        }(i)
    }

    fmt.Scanln()
}

A biblioteca sync/atomic nos permite sinalizar e armazenar um conteúdo de forma segura e garantindo sua unicidade, bem parecido com sync.Map, onde ele está armazenando em um storage e aceitando concorrência em sua implementação. O problema que tivemos que usar mais uma funcionalidade, mais recurso e consecutivamente um pouco mais lento nossa execução.

sync.Once clean e poderoso

Temos o tipo “Once” na biblioteca sync, lembrando que esta biblioteca nativa em Golang é muito poderosa e temos que explora-la o máximo que conseguirmos, o objeto sync.Once executará uma ação exatamente uma vez e não mais, era o que faltava para nosso código ficar ainda mais poderoso e clean.

// call somente
// uma unica vez
var once sync.Once

type DriverPg struct {
    conn string
}

// variavel Global
var instance *DriverPg

func Connect() *DriverPg {

    once.Do(func() {

        instance = &DriverPg{conn: "DriverConnectPostgres"}
    })

    return instance
}

func main() {

    // chamada
    go func() {
        time.Sleep(time.Millisecond * 600)
        fmt.Println(*Connect())
    }()

    // 100 goroutine
    for i := 0; i < 100; i++ {

        go func(ix int) {
            time.Sleep(time.Millisecond * 60)
            fmt.Println(ix, " = ", Connect().conn)
        }(i)
    }

    fmt.Scanln()
}

Com esta abordagem e cenário proposto nosso código além de ficar mais clean ficou bem melhor, a função sync.Once garante a unicidade de nossa instância, nosso código agora pode ter 100 goroutines ou muito mais conforme a sua necessidade, coloca-los em concorrência não teremos problemas de “Thread Safe” ou checagem agressiva como vimos acima em outras abordagens. Uma forma simples e segura de escrever o código Golang para implementação do Pattern Singleton.

init( ) Uma outra abordagem

Uma outra abordagem e também válida é utilizar o init( ), ele é executado somente uma única vez e é chamado antes da função maim.
Confere o código abaixo:

type DriverPg struct {
    conn string
}

var instance *DriverPg

func Connect() *DriverPg {

    instance = &DriverPg{conn: "DriverConnectPostgres"}
    return instance
}

func init() {

    Connect()
}

func main() {

    // chamada
    go func() {
        time.Sleep(time.Millisecond * 600)
        fmt.Println(instance.conn)
    }()

    go func() {

        fmt.Println(*Connect())
    }()

    // 100 goroutine
    for i := 0; i < 100; i++ {

        go func(ix int) {
            time.Sleep(time.Millisecond * 60)
            fmt.Println(ix, " = ", instance.conn)
        }(i)
    }

    fmt.Scanln()
}

Porém esta abordagem existe uma desvantagem quando usamos init( ). Percebesse claramente que não é segura, nada impede de fazer uma chamada direta na função “Connect” como ocorreu na linha #28 além de que existe uma limitação no uso do init( ) com relação ao seu tempo de carregamento e o mais importante em Golang podemos ter vários init sendo executados não somente em um arquivo ou pacote mas em vários, e existe uma ordem de execução entre eles.

A função init( ) não aceita argumentos nem retorna nenhum valor. Em contraste com nossa abordagem usando sync.Once, o identificador init() não é declarado, portanto não pode ser referenciado.

O melhor cenário é escrever códigos que não dependam da ordem de inicialização, em versões anteriores do golang houve algumas reclamações e diversos problemas relatados, não escrevam códigos em um ***init( )***que você precise de garantias de execução em determinado momento. A solução quando precisa de garantia explícita é escrever chamadas explícitas.

Para ter mais detalhes tem um página só disto em Golang https://golang.org/doc/effective_go.html#initialization, vale a pena a leitura detalhada sobre o init( ), é uma implementação poderosa e robusta nas versões atuais do Golang mas sempre é bom ficar atento.

Variável recebendo a função

Uma outra abordagem e também válida é utilizar uma variável global recebendo a função em um escopo global, sabemos que em Golang as variáveis são atribuídas e declaradas antes da chamada do init( ) e da função main, então nesta abordagem o método retorna exatamente uma única vez a instância. Confere o código abaixo:

type DriverPg struct {
    conn string
}

var instance *DriverPg

var instanceNew = *Connect()

func Connect() *DriverPg {

    if instance == nil {

        // <--- NOT THREAD SAFE
        instance = &DriverPg{conn: "DriverConnectPostgres"}
    }

    return instance
}

func main() {

    // chamada
    go func() {
        time.Sleep(time.Millisecond * 600)
        fmt.Println("goroutine 1: ", instanceNew.conn)
    }()

    go func() {

        fmt.Println("goroutine 2: ", *Connect())
    }()

    fmt.Scanln()
}

Esta abordagem é falha por que nada garante que a função irá ser chamado novamente em alguma parte do código, como ocorreu na linha #25 a função foi chamada novamente, na linha #30 é feito a instância do nosso singleton, porém nada garante esta unicidade.

Conclusão

O ideal sem dúvida é utilização do sync.Once que garante com certeza a unicidade e que seja “Thread Safe” nos garantindo que não ocorra uma “race condition”, ele só permite que a função seja executada somente uma única vez Golang flexibilizou e automatizou toda complexidade que teríamos em outras langs se fôssemos trabalhar com concorrência e simultaneidade. Realmente Golang ficou poderoso nestas abordagens, tornando-se simples de implementar e entender.

Quando falamos de concorrência toda nossa forma de pensar e codar as soluções utilizando Golang mudam drasticamente. Existem vários cenários que precisamos aplicar padrões e práticas em nossos projetos para aproveitar o máximo do poder que o Golang oferece.

Todo projeto que participo torna-se quase um “mantra” entre as equipes de desenvolvimento fazer diversos testes e revisões para aproveitar o máximo que a linguagem proporciona. Quanto mais aprofundamos nos estudos mais descobrimos que pouco sabemos sobre a linguagem. O legal de tudo é o desafio, quando trabalhamos com goroutines em Golang precisamos entender o quanto antes as funcionalidades e o que é possível fazer, comportamentos, segurança das goroutines são todos essenciais para melhorar cada vez mais o nosso código.

Caso tenha interesse em acompanhar ou trocar ideias sejam elas a nível iniciante, intermediário ou “hardcore” sobre a linguagem Golang existe alguns grupos de Golang espalhados na internet dois deles em especial sempre que possível estou presente é o do https://t.me/go_br (GoBr) e o gophers.slack.com, comunidades ativas usando Golang, sempre estão compartilhando ideias, projetos, vagas e dúvidas todo o tempo e a todo momento estamos reaprendendo.

Espero ter ajudado a esclarecer um pouco as dúvidas sobre utilização do Pattern Singleton, utilizando variáveis globais, goroutines, sync.Once, Init( ), mutex e diversos outros pontos importantes e técnicos abordados no artigo.

Logo abaixo está todos os códigos fontes que utilizamos como exemplo no artigo caso tenha interesse de baixar e testar fique a vontade.

Códigos fontes e exemplos do artigo

https://github.com/jeffotoni/medium-posts

Gostaria de agradecer alguns colegas que ajudaram na revisão deste artigo para mantermos a qualidade do conteúdo e deixa-lo denso sem ficar complexo e jato. Obrigado :

Joelson

, Marco Paganinii, Francisco Oliveira

No próximo artigo que está no forno será sobre lambdas, como escrever lambdas em Golang, será mais um desafio bem interessante, que estou preparando.

Quem curtiu e chegou até o final deixa uma palminha aí… Obrigado 🤘🤓

Estou deixando um link aqui onde irá conseguir visualizar diversas aplicações, libs, frameworks serviços implementadas em Go e suas respectivas categorias. Neste link

Cenários como desenvolvimento para backend em um âmbito geral Go❤️ é muito animal ou melhor surreal. Não é uma questão só de linguagem mas de necessidade, nos dias atuais o quanto antes conseguirmos diminuir nosso custo computacional que é diretamente relacionado com nosso custo financeiro é bem vindo. A linguagem Go tem este objetivo quanto o assunto é recurso computacional, interessante não é ?

Abaixo uma imagem com algumas das aplicações mais utilizadas pela comunidade DevOps.

Alguns tipos de aplicações que Go brilha mais:

. Web backend (com diversos frameworks disponíveis)

. Web Assembly (um dos frameworks vugu)

. Microservices (alguns frameworks: Go Micro, Go Kit, Gizmo, Kite)

. Fragments services (Termo citado pelo @jeffotoni em um grupo de discussão de microservices)

. Lambdas (FaaS example)

. Client Server

. IoT (alguns frameworks)

. Boots (alguns aqui)

. Aplicações Client que usam tecnologia Web

. Desktop Usando Qt+QML, Lib Nativa Win (example Qt, widgets Qt, Qml)

. Aplicações de Rede

. Aplicações para protocolos

. Aplicações rEST,

. Aplicações SOAP

. Aplicações GraphQL

. Aplicações RCP

. Aplicações TCP

. Aplicações gRPC

. Aplicações Websocket

. GopherJS (compiles Go to JavaScript)

. CLI (Command Line)

O objetivo deste post é apresentar o que é a linguagem Go e, porque ela é tão poderosa. Apresentando alguns conceitos e pontos importantes sobre a linguagem Go que muita das vezes é expressado de forma equivocada em diversos artigos encontrados na internet e grupos de discussões de linguagens de programação. Acredito que os pontos fracos e problemas gerados por diversas outras linguagens de programação ao longo destas décadas fez com que Go torna-se o que é hoje. E para explicarmos como isto é possível iremos voltar ao início de tudo, onde tudo começou.

package main

func main() {
    println("Hello all folks!")
}

Menos é exponencialmente Mais

A equipe de desenvolvedores do Go dizem que sua criação é uma tentativa de tornar os programadores mais produtivos. Melhorando o processo de desenvolvimento de software no Google. O primeiro objetivo foi criar uma linguagem melhor para enfrentar os desafios da simultaneidade escalável, ou seja software que lida com muitas preocupações simultaneamente, um exemplo seria a coordenação de mil servidores back-end enviando tráfego de rede todo o tempo.

Manter a linguagem Go pequena permite objetivos mais importantes. Ser pequeno torna o Go mais fácil de aprender, mais fácil de entender, mais fácil de implementar, mais fácil de reimplementar, mais fácil de depurar, mais fácil de ajustar e mais fácil de evoluir. Fazer menos permite mais. É uma expressão utilizada pela equipe de desenvolvimento do Go: “Do Less. Enable More” seria o equilíbrio entre os universo de problemas existentes e o que Go poderá ajudar a resolver bem tais problemas. Go explicitamente não foi projetado para resolver todos os problemas em vez disso fizeram o suficiente para possamos criar as próprias soluções personalizadas com facilidade, mas deixando bem claro que Go não pode fazer tudo.

Go foi projetado pelo Google em 2007 para melhorar a produtividade de programação em uma era de multicore, rede de máquinas e grandes bases de código. Os designers queriam abordar críticas de outras línguas em uso no Google, mas manter suas características úteis.
Os criadores Rob Pike, Ken Thompson e Robert Griesemer mantiveram a sintaxe de Go semelhante ao C. No final de 2008 Russ Cox juntou-se a equipe e ajudou a mudar a linguagem e as bibliotecas de protótipo para realidade.

A linguagem Go foi lançada em 2009 com propósito de facilitar a resolução de problemas quando o assunto é desenvolvimento em camadas de rede, escalabilidade, desempenho, produtividade e o mais importante concorrência. O próprio Rob Pike declarou que “Go foi projetado para tratar de um conjunto de problemas de engenharia de software a que estávamos expostos na construção de grandes softwares de servidor”.

Go teve influências de diversas linguagens de programação e paradigmas diferentes dentre elas: Alef, APL, BCPL, C, CSP, Limbo, Modula, Newsqueak, Oberon, occam, Pascal, Smalltalk e Cristal, percebe-se que utilizaram do que tinham de melhor e criou algo novo e enxuto, com o mínimo necessário para resolver os problemas propostos, sem perder sua simplicidade. Acredito que isto podemos chamar de inovação. Go inovou ao quebrar os paradigmas de linguagens e implementar algo novo de forma simples e muito poderosa.

Polêmicas

Foram deixadas de fora diversas características que as linguagens modernas contrariando e indo em direção oposta das outras linguagens atuais algumas funcionalidades como o uso de: declarações de imutabilidade, tipos de dados de correspondência de padrões, generics, tratamento de exceção, Herança, programação genérica e sobrecarga de métodos e diversos outros pontos. Todos os recursos acima foram criticados e apontados para os criadores de Go, que responderam: “Essas omissões foram simplificações que contribuem para a força de Go*”. Há muitas coisas na linguagem e bibliotecas Go que diferem das práticas modernas, foi uma decisão da equipe de desenvolvimento do **Go: “**às vezes vale a pena tentar uma abordagem diferente”.*

Todos estão convidados a ajudar e contribuir se assim desejar, podem abrir propostas para novos recursos e tudo relacionado ao ecossistema da linguagem. O código fonte de Go está disponível no GitHub . A documentação sobre como você pode contribuir com o idioma é fornecida aqui.

Goroutines em vez de threads

Um dos principais objetivos da linguagem de programação Go é tornar a simultaneidade mais simples, rápida e eficiente.

Goroutines são leves e tiram proveito de todo o poder de processamento disponível. Goroutines existe apenas no espaço virtual do tempo de execução Go e não no sistema operacional.

Goroutine é um método/função que pode ser executado independentemente junto com outras goroutines. Cada atividade simultânea na linguagem Go é geralmente denominada Goroutine.

Um dos pontos mais relevantes e importantes é o trabalho com concorrência, ele inovou ao quebrar o modelo tradicional de threads e sua forma de utilização ao criar um novo modelo, as goroutines. As goroutines são responsáveis por realizar execuções em Go de forma assíncrona. São muito poderosas e uma simples máquina de 1G de Ram poderá subir milhares delas.

Goroutines fazem parte de tornar a simultaneidade fácil de usar. As goroutines, pode ser muito barata: eles têm pouca sobrecarga além da memória para a pilha, que é apenas alguns kilobytes. Para tornar as pilhas pequenas, o tempo de execução de Go usa pilhas redimensionáveis ​​e delimitadas. Uma goroutine recém lançada recebe alguns kilobytes, o que é quase sempre suficiente. Quando não é, o tempo de execução aumenta (e encolhe) a memória para armazenar a pilha automaticamente, permitindo que muitos goroutines vivam em uma quantidade modesta de memória. A sobrecarga da CPU tem em média três instruções baratas por chamada de função. É prático criar centenas de milhares de goroutines no mesmo espaço de endereço. Se goroutines fossem apenas threads, os recursos do sistema acabariam em um número muito menor.

O design de Go foi fortemente influenciado pelo artigo de C.A.R. Hoare 1978 “Communicating sequential processes” (Comunicação de processos sequenciais).

Simultaneidade nas ideias do CSP

Um dos modelos mais bem-sucedidos para fornecer suporte linguístico de alto nível para concorrência é o Hoare’s Communicating Sequential Processes, ou CSP. Occam e Erlang são duas línguas bem conhecidas que derivam de CSP. As primitivas de concorrência de Go derivam de uma parte diferente da árvore genealógica cuja principal contribuição é a poderosa noção de canais como objetos de primeira classe. A experiência com várias linguagens anteriores mostraram que o modelo CSP se encaixa bem em uma estrutura de linguagem procedural.

A maior diferença entre Go e o modelo CSP, além da sintaxe, é que o Go modela os canais de comunicação simultânea explicitamente como canais, enquanto os processos da linguagem de Hoare enviam mensagens diretamente uns aos outros, semelhante ao Erlang.

Bem para chegar neste resultado Go novamente sofreu críticas do modelo adotado. Go incorpora uma variante do CSP (Comunicação de processos sequenciais) é uma linguagem formal para descrever padrões de interação em sistemas concorrentes com canais de primeira classe. Não foi adotada uma abordagem de gravação única para valorizar a semântica no contexto da computação concorrente como é feita no Erlang, ao invés disto adotaram algo prático e que resultou em algo poderoso, permitindo programação simultânea simples e segura, mas não proíbe programação incorreta. E o lema criado foi: “Não se comunique compartilhando memória, compartilhe memória comunicando-se”.
A simplicidade e o suporte para concorrências oferecidas por Go gera robustez.

Concorrência é diferente de Paralelismo

Uma das famosas frases é: “Concorrência é sobre lidar com muitas coisas ao mesmo tempo. Paralelismo é fazer muitas coisas ao mesmo tempo”. Concorrência é a composição de cálculos de execução independente. Concorrência é uma maneira de estruturar software, e definitivamente não é paralelismo embora permita o paralelismo.
Se você tiver apenas um processador, seu programa ainda pode ser concorrente, mas não pode ser paralelo. Por outro lado, um programa concorrente bem escrito pode ser executado de forma eficiente em paralelo em um multiprocessador. Sugiro dar uma conferida neste vídeo de uma palestra do Rob Pike “Concorrência não é Paralelismo”.

Concorrência em Go é muito poderosa e também simples de codar está foi a intensão dos engenheiros que desenvolveram Go. A resolução de muitos problemas é bem mais eficiente utilizando concorrência e este é o poder de Go, por isto, se tornou um Deus quando o assunto é concorrência. Devido a isto, problemas englobados neste universo serão resolvidos com muita eficiência e o mais importante, com muito pouco recurso computacional.

Quando falamos de concorrência temos que ressaltar que existem alguns patterns e descrevo eles logo abaixo, e existe alguns tipos de cargas de trabalhos eles serão nossa bússola para determinar nosso ponto de equilíbrio quando tivermos que resolver problemas evolvendo concorrência.

Workloads: CPU-Bound & IO-Bound

Uma thread pode fazer dois tipos de cargas de trabalhos (*Workloads*): CPU-Bound e o IO-Bound.

CPU-Bound: Esta carga de trabalho nunca irá cria uma situação em que a thread pode ser colocado em estados de espera. Ele estará constantemente fazendo cálculos. Uma thread calculando pi para décima oitava potência seria limitado pela CPU. (curiosidade: Emma Haruka Iwao é uma cientista da computação japonesa e Engenheira de Desenvolvimento Cloud do Google. Em 2019, Haruka Iwao calculou o valor de pi mais preciso do mundo, que incluiu 31,4 trilhões de dígitos). Este tipo de carga de trabalho, trabalhos ligadas à CPU, você precisa do paralelismo para aproveitar a simultaneidade, mais goroutines não irá ajuda-lo e não serão eficientes, podendo atrasar ainda mais as cargas de trabalho a serem executadas, isto ocorre devido ao custo de latência (o tempo gasto) de mover Goroutines dentro e fora da thread do sistema operacional.

IO-Bound: Neste tipo de carga de trabalho as threads entram em estados de espera. Um bom exemplo seria uma solicitação de acesso a um recurso pela rede ou fazer chamadas para o sistema operacional. Uma thread que precisa acessar um banco de dados, eventos de sincronização (mutex, atomic), todos estes exemplos fazem com que a thread aguarde então poderíamos dizer que são do tipo de trabalho IO-Bound. Neste tipo de carga de trabalho você não precisa de paralelismo para usar a simultaneidade um único core físico já seria suficiente para uma boa execução de várias Goroutines. As Goroutines estão entrando e saindo dos estados de espera como parte de sua carga de trabalho. Neste tipo de carga de trabalho ter mais Goroutines do que cores físicos pode acelerar a execução porque o custo de latência de mover Goroutines dentro e fora do thread do sistema operacional não está criando um evento. Sua carga de trabalho é naturalmente interrompida e isso permite que um Goroutine diferente aproveite o mesmo core físico ao invés de permitir que ele fique ocioso.

Goroutine e Pattern

Existem alguns patterns para concorrência, dentre eles: Fan-In e Fan-Out.
Fan-Out: Múltiplas funções podem ler do mesmo canal até que esse canal seja fechado, isso é chamado de fan-out . Isso fornece uma maneira de distribuir o trabalho entre um grupo de trabalhadores para fazer uso da CPU e E/S de forma concorrente.

Fan-In:
É a forma de ler a partir de múltiplas entradas e prosseguir até que todas estejam fechadas, multiplexando os canais de entrada em um único canal que está fechado quando todas as entradas estão fechadas. Isso é chamado fan-in.

Pipeline: Não há definição formal de um pipeline em Go, é apenas um dos muitos tipos de programas concorrentes. Informalmente, um pipeline é uma série de estágios conectados por canais, onde cada estágio é um grupo de goroutines executando a mesma função. Em cada etapa, os goroutines:

• Recebem valores do upstream via canais de entrada;

• Executam alguma função nesses dados, geralmente produzindo novos valores;

• Enviam valores a jusante através de canais de saída.

Cada estágio possui vários canais de entrada e saída, exceto o primeiro e o último estágio, que possuem apenas canais de entrada ou saída, respectivamente.

Para se ter uma pequena ideia, em uma máquina de 1CPU e 1G Ram, conseguimos com uma API simples feita em Go, com poucas linhas de código, aguentar de 5k a 6k de requisições por segundo em um protocolo TCP, utilizando RPC ou TCP nativo e gravando em um banco de dados relacional como o Postgresql, sem derrubá-lo e consumindo em média somente 60Mb a 70Mb de memória e de 8% a 15% de CPU para que isto seja possível utilizamos um “Worker Poll” que é um Fan-out.

Que aprofundar ainda mais sobre concorrência? Só entrar neste link. Quer testar e visualizar alguns exemplos? Click Aqui.
Vamos criar um post só para falarmos sobre Goroutine é um tópico extenso muito cheio de detalhes e muitas situações interessantes. Sabemos que o suporte a concorrência em Go o torna um Deus perante aos problemas que são melhores resolvidos usando concorrência.

Go é uma linguagem compilada, um like de C, muito focada na produtividade. Para projetos simples ou complexos Go sempre será uma excelente alternativa, pois torna tudo mais simples e enxuto, fácil de codar e dar manutenção.

package main

import "fmt"

func main() {
    fmt.Printf("Olá, eu amo Go!\n")
}

Não existe ainda bala de prata

Uma solução ou ferramenta para resolver todos os problemas não existe ainda é claro. O que sabemos é que existe uma infinidade de soluções desenvolvidas em diversas linguagens todas com um propósito e cada uma delas tem suas características. Por este motivo existem paradigmas de programação é uma forma de classificar as linguagens baseado em suas funcionalidades facilitando o entendimento e o contexto que ela poderá está melhor inserida e é claro com isto teremos uma visão sobre sua estruturação e execução das linguagens.

Esta cada vez mais comum linguagens suportarem múltiplos paradigmas. Sabemos que existem classes diferentes na computação quando o assunto é resolver problemas, quanto mais próximos destes assuntos estivermos, mais confortáveis estaremos para escolher uma determinada linguagem para resolver problemas, e assim sabermos qual ferramenta usar no momento certo. Na prática esta tarefa não é tão fácil mas o que sabemos é que ainda não criaram a bala de prata para resolver todos os problemas de uma única vez com apenas uma linguagem, se existisse não existiria mais P versus NP e todos os problemas poderiam ser resolvidos em tempo polinomial.

As coisas Boas de Go

• Não possui Generics;

• Não possui sobrecarga do operador;

• Não possui aritmética de ponteiros;

• Não é explícito o gerenciamento de Threads;

• Possui inferência de tipos;

• As Dependências são claras;

• A sintaxe é limpa;

• A semântica é clara;

• A composição e não herança;

• GC Nativo (Garbage collector);

• Possui Goroutines;

• Suporte nativo a programação concorrente;

• Funções de Primeira Classe (podemos passar funções como parâmetros);

• Multiplataforma;

• Open Source;

• Curva de Aprendizado muito baixa ou seja fácil de aprender;

• Altamente produtivo;

• Resolve problemas de escalabilidade;

• Pode diminui seus custos de servidores drasticamente;

• Diversos problemas pensados na perspectiva Go torna-se muito mais fáceis de tratar e resolvê-los;

• Possui somente 25 Palavras reservadas;

• Multi-paradigma: concorrente, funcional, imperativa, orientada a objeto;

• Memory Safe.

Sabemos que diversos pontos acima serão criticados mas na prática e com o tempo percebemos que todas as simplificações omitidas tornaram Go uma linguagem ainda mais poderosa.

Não há Generics ainda

Existem motivos fortes de Go não ter implementado Generics no inicio do projeto, há uma discussão nas comunidades em geral sobre este tema. Go deixou de fora diversas funcionalidades, dentre elas: “Generics” que em sua concepção iria comprometer diretamente o desempenho e propósito que a linguagem Go propusera a resolver. Os que reclamam são em sua grande maioria desenvolvedores que vieram de linguagens que usam esse recurso.
No dia 29 de novembro de 2018 os responsáveis pela manutenção do código fonte de Go abriram a possibilidade de enviarem proposta de novas funcionalidades com todos os detalhes para que possam
analisá-las e talvez implementá-las na versão Go 2.0, para terem uma boa noção leiam este arquivo clicando aqui.

Generics é uma forma de fazer cast de tipos diferentes em métodos e classes. É um tipo de Polimorfismo de inclusão e paramétrico, são funções que operam da mesma forma sobre objetos de tipos diferentes ou seja funções genéricas.

Exemplo:
1. Imagina um método que recebe um vetor do tipo int, e imprima na tela.
2. Imagina que precise fazer isso agora com tipo String e do tipo float, teria que fazer novos métodos ou funções várias vezes, repetindo o código.

Solução: Para não precisar criar vários métodos é criado somente um método como generics para poder receber qualquer tipo.

Percebe-se que isso só é problemas em linguagens que precisam declarar tipos de variáveis ou funções etc, em linguagens dinâmicas como PHP por exemplo não tem essa necessidade, não vou dizer linguagens fortemente tipadas ou fracamente tipadas pois é um pouco mais complexo que isso e isto levaria a um outra discussão.

Em Go conseguimos resolver todos os problemas dessa natureza usando reflect e outras usando interface. Go adota uma abordagem incomum para programação orientada a objeto então não faz muito sentido no momento ter uma funcionalidade que não agrega tanto para contribuir com o verdadeiro propósito que a linguagem foi construída, além do recurso deixar todo processo de execução e compilação bem mais lento e complexo.

Porém no ano de 2020 a proposta para Generics ficou ainda mais próximo de tornar-se realidade não temos dúvidas que veem algo por aí relacionado ao Generics então vamos ver na prática como isto seria possível usando Go.😎

Abaixo três exemplos com três propostas para resolver o problema desta forma irá conseguir perceber quando falamos em Generics😊.

Copiando e Colando funções com tipos específicos

package main

// Pega um slice de qualquer tipo e a inverte.
func Reverses(list []string) []string {
    i := 0
    j := len(list) - 1
    for i < j {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
    return list
}

// Pega um slice de qualquer tipo e a inverte.
func Reversei(list []int) []int {
    i := 0
    j := len(list) - 1
    for i < j {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
    return list
}

func main() {
    s := []string{"otoni","jeff","Go"}
    Reverses(s)
    println(s[0], s[1], s[2])

    i := []int{2020,2012,2009}    
    Reversei(i)    
    println(i[0], i[1], i[2])
}

Usando Interface

package main

// Pega um slice de qualquer tipo e a inverte.
func Reverse(in interface{}) interface{} {
    switch in.(type) {
        case []string:
        list := []string(in.([]string))
        i := 0
        j := len(list) - 1
        for i < j {
                list[i], list[j] = list[j], list[i]
           i++
           j--
            }
            return list

         case []int:
        list := []int(in.([]int))
        i := 0
        j := len(list) - 1
        for i < j {
           list[i], list[j] = list[j], list[i]
           i++
           j--
            }
            return list
    }
    return nil
}

func main() {
    s := []string{"otoni","jeff","Go"}
    Reverse(s)
    println(s[0], s[1], s[2])

    i := []int{2020,2012,2009}    
    Reverse(i)    
    println(i[0], i[1], i[2])
}

Utilizando Generics

// https://go2goplay.golang.org/
package main

import (
    "fmt"
)

// The playground now supports parentheses or square brackets (only one at
// a time) for generic type and function declarations and instantiations.
// By default, parentheses are expected. To switch to square brackets,
// the first generic declaration in the source must use square brackets.

func Print[type T] (s []T){
    for _, v := range s {
        fmt.Print(v)
    }
    fmt.Println("")
}

func Reverse[type T](list []T) {
    i := 0
    j := len(list) - 1
    for i < j {
        list[i], list[j] = list[j], list[i]
        i++
        j--
    }
}

func main() {
        var i []interface{}
        i = append(i, "jeffotoni")
        i = append(i, " ano de 2020 ")
        i = append(i, []string{"otoni", "jeff", "Go"})
    i = append(i, []int{2020, 2012, 2009})
        Print(i)

    s := []string{"otoni", "jeff", "Go"}
    Reverse(s)
    Print(s)

    intt := []int{2020, 2012, 2009}
    Reverse(intt)
    Print(intt)
}

Composição não herança

A abordagem adotada por Go foge da regra e é incomum para programação orientada a objetos*, permitindo métodos em qualquer tipo, não apenas classes, mas sem qualquer forma de herança baseada em tipos, como subclasses. Isso significa que não há hierarquia de tipos. Isto não é um bug, não é uma desvantagem ou erro, é uma escolha intencional de design dos desenvolvedores de Go. Embora as hierarquias de tipos tenham sido usadas para construir softwares bem-sucedidos, é uma postura e opinião da equipe de desenvolvedores do *Go, onde preferiram dar um passo para trás ao invés de fazerem igual a todos, o mesmo modelo repetitivo em diversas linguagens.

Interfaces são implícitas

Em vez disso, o Go possui interfaces, que são apenas um conjunto de métodos e nada mais.
Exemplo:

type Gemetric interface {
  area() float64
  perim() float64
}

Todos os tipos de dados que implementam esses métodos satisfazem essa interface implicitamente, não há implements na declaração. A satisfação da interface é verificada estaticamente em tempo de compilação, portanto, apesar das interfaces de desacoplamento, elas são seguras quanto ao tipo.

Um tipo geralmente satisfaz muitas interfaces, cada uma correspondendo a um subconjunto de seus métodos. Essa fluidez de satisfação de interface incentiva uma abordagem diferente para a construção de software uma quebra no paradigma existente.

Por que as interfaces não são explícitas ?

A programação orientada a objetos fornece uma visão poderosa: que o comportamento dos dados pode ser generalizado independentemente da representação desses dados. O modelo funciona melhor quando o comportamento (conjunto de métodos) é fixo, mas depois que você insere uma subclasse em um tipo e adiciona um método, os comportamentos não são mais idênticos . Se, em vez disso, o conjunto de comportamentos for fixo, como nas interfaces definidas estaticamente em Go, a uniformidade de comportamento permite que dados e programas sejam compostos uniformemente, ortogonalmente e com segurança.
As hierarquias de tipo resultam em código frágil. Go estimula a composição e não herança, usando interfaces simples, geralmente de um método, para definir comportamentos triviais que servem como limites claros e compreensíveis entre os componentes e a eliminação da hierarquia de tipos também elimina uma forma de hierarquia de dependência.
Os designs não são como métodos hierárquicos herdados de subtipo. Eles são mais soltos, orgânicos, desacoplados, independentes e portanto escaláveis.

package main

import "fmt"
import "math"

type Gemetric interface {
    area() float64
    perim() float64
}

type rect struct {
    width, height float64
}

type circle struct {
    radius float64
}

func (r rect) area() float64 {
    return r.width * r.height
}

func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}

func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)
    measure(c)
}

Duck typing

O Go suporta “Duck typing”, é um estilo de tipagem em que os métodos e propriedades de um objeto determinam a semântica válida, em vez de sua herança de uma classe particular ou implementação de uma interface explicita. O nome do conceito refere-se ao teste do pato, atribuído à James Whitcomb Riley. Isso faz com que o Go se pareça com uma linguagem dinâmica.

Go usa “Tipagem Estrutural“ em métodos para determinar a compatibilidade de um tipo com uma interface. Não há hierarquias de tipos e a “Tipagem Estrutural” é uma alternativa interessante à herança clássica em linguagens com tipagem estática. Ele permite que você escreva algoritmos genéricos sem obscurecer a definição de um tipo em um mar de interfaces. Talvez mais importante, ajuda as linguagens com tipagem estática a capturar a sensação e a produtividade das linguagens dinamicamente tipificadas.

“Duck typing” ocorre em tempo de execução e “Tipagem Estrutural” que ocorre em tempo de compilação. Go não da suporte a orientação a objetos como é implementado nas linguagens como C#, Java ou mesmo C ++, não possui herança e honestamente fico muito feliz com isto, mas oferece alguns recursos como composição e interfaces.

package main

import (
    "fmt"
)

type familia interface {
    dados() string
}

type pai struct {
    Nome  string
    Idade int
    Cpf   string `json:"campo-x"`
}

func (p pai) dados() string {
    return fmt.Sprintf("Nome: %s, Idade: %d", p.Nome, p.Idade)
}

type filho struct {
    pai
    email string
}

func (f filho) dados() string {
    return fmt.Sprintf("Nome: %s, Idade: %d, Email: %s", f.Nome, f.Idade, f.email)
}

func mostraDados(membro familia) {
    fmt.Println(membro.dados())
}
func main() {
    pai := new(pai)
    pai.Nome = "Jeff"
    pai.Idade = 50
    pai.Cpf = "00.xxx.xxx-xx"

    filho := new(filho)
    filho.Nome = "Arthur"
    filho.Idade = 20
    filho.email = "arthur@gmail.com"

    mostraDados(pai)
    mostraDados(filho)
 }

Muito suporte a bibliotecas de terceiros

No cenário atual Go disparou como linguagem de programação e todos os grandes, médios e pequenos players existentes estão desenvolvendo suas libs, sdks, clients etc. na linguagem Go. Existe milhares de iniciativas e muitas bibliotecas de terceiros. Tudo colabora para que isto ocorra, a comunidade Go é muito forte, cresce a cada dia, tem uma curva de aceitação muito alta e com isto facilita sua entrada nas empresas e sua utilização pelos desenvolvedores.

O resultado disto é a disseminação em massa na internet com bibliotecas escritas em Go. Existe também bibliotecas que estão abandonadas, como em qualquer outra linguagem mas funcionais. Mas o número de bibliotecas escritas em Go é muito mas muito grande. Diversas empresas estão reescrevendo suas plataformas em Go isto é uma vertente que não para de crescer. E dia após dia o número de ferramentas para DevOps cresce, e com isto a aceitação e o aumento de novos adeptos em Go cresce na cultura e comunidade DevOps.

Gerenciamento de dependências nativo

Go teve um momento de trevas e durante um bom tempo não teve um gerenciador de dependências oficial. Após algumas tentativas e diversos posts e discussões sobre o assunto. O protótipo inicial VGO foi anunciado em fevereiro de 2018. Em julho de 2018, o suporte para módulos com versão foi instalado no repositório principal. O Go 1.11 foi lançado em agosto de 2018.
O Go 1.11 inclui suporte preliminar para módulos com versão, conforme proposto aqui . Mesmo que alguns detalhes possam mudar, versões futuras suportarão módulos definidos usando Go 1.11 ou 1.12, os testes e utilização em massa que estamos atualmente fazendo usando “go mod” acreditamos que não tem volta, ficou simplesmente fantástico, mesmo sendo anunciado como um módulo experimental está muito simples e poderoso.

Go é uma linguagem muito nova e o que surpreende é que em muito pouco tempo já exista uma infinidade de bibliotecas disponíveis para diversas necessidades e inúmeros tipos especificados de problemas e não para de crescer.

$ go mod init yourapp
$ go build

Não é mais obrigatório o $GOPATH

Após a implementação do controle de versão o VGO em Go, temos a possibilidade agora de não precisar que nossos projetos estejam abaixo do $GOPATH, agora podemos criar nossos projetos em qualquer diretório fora do $GOPATH. Esta funcionalidade só é possível devido o controle de versão, quando usamos o “go mod” os nossos workspaces de projetos passam a ser controlados de uma nova forma, basta executar o comando “go mod init yourapp” é criado um arquivo “go.mod” nele irá conter a localização do seu path e a versão que ele encontra-se. Muito simples e lindo.
Toda vez que formos executar nosso projeto Go podemos utilizar a variável ambiente “GO111MODUL=yes|no” para determinar se iremos utilizar o “go mod” ou não.

Garbage collector (GC)

Os GCs são peças complexas de software, são décadas de pesquisas e implementações, diversas tentativas de cientistas da computação em fazer um GC melhorado e confiável. Não é uma tarefa simples, devido a isto existe uma corrente muito grande na internet descrevendo os prós e contras de um GC. O que temos que levar em consideração é que independente do resultado, se não tivermos um GC teríamos que construir um para resolver o problema de alocação.

Geralmente existem duas maneiras de alocar memória em Go: na pilha e o heap. Em geral os desenvolvedores estão familiarizados com a pilha basta escrever um programa recursivo e irá perceber um estouro da pilha caso não faça corretamente. O heap, por outro lado, é um pool de memória que pode ser usado para alocação dinâmica.

As alocações de pilha são ótimas porque elas só vivem durante a vida útil da função da qual fazem parte. As alocações de heap, no entanto, não serão desalocadas automaticamente quando saem do escopo. Para evitar que o heap fique desassociado, devemos desalocar explicitamente ou, no caso de linguagens de programação com gerenciamento de memória (como Go), confiar no coletor de lixo para localizar e excluir objetos que não são mais referenciados.

De um modo geral, em linguagens com um GC, quanto mais você puder armazenar na pilha, melhor, uma vez que essas alocações nunca são vistas pelo GC. Compiladores usam uma técnica chamada análise de escape para determinar se algo pode ser alocado na pilha ou deve ser colocado no heap.

Na prática, escrever programas que forcem o compilador a somente alocar na pilha pode ser muito limitante, e assim, no Go, nós aproveitamos seu maravilhoso GC para fazer o trabalho de manter nosso heap limpo.

Quer da uma conferida e aprofundar ainda mais no assunto entre neste link escrito por Richard L. Hudson https://blog.golang.org/ismmkeynote.

Alguns tipos de aplicações implementadas em Go

Go é uma linguagem de uso geral. Neste link você conseguirá visualizar diversas aplicações implementadas em Go e suas respectivas categorias.

Alguns tipos:

. Web backend (com diversos frameworks disponíveis)
. Web Assembly (um dos frameworks vugu)
. Microservices (alguns frameworks: Go Micro, Go Kit, Gizmo, Kite)
. Fragments services (Termo citado pelo @jeffotoni em um grupo de discussão de microservices)
. Lambdas (FaaS example)
. Client Server
. Aplicações em terminal (utilizando a lib tview)
. IoT (alguns frameworks)
. Boots (alguns aqui)
. Aplicações Client que usam tecnologia Web
. Desktop Usando Qt+QML, Lib Nativa Win (example Qt, widgets Qt, Qml)
. Aplicações de Rede
. Aplicações para protocolos
. Aplicações rEST,
. Aplicações SOAP
. Aplicações GraphQL
. Aplicações RCP
. Aplicações TCP
. Aplicações gRPC
. Aplicações Websocket
. GopherJS (compiles Go to JavaScript)

Go: A linguagem que mais cresce para backend

Go foi projetado pelo Google em 2007 para melhorar a produtividade de programação em uma era de multicore, rede de máquinas e grandes bases de código. Os designers queriam abordar críticas de outras línguagens em uso no Google, mas manter suas características úteis. Os criadores Rob Pike, Ken Thompson e Robert Griesemer mantiveram a sintaxe de Go semelhante ao C. No final de 2008 Russ Cox juntou-se a equipe e ajudou a mudar a linguagem e as bibliotecas de protótipo para realidade.

A linguagem Go foi lançada em 2009 com propósito de facilitar a resolução de problemas quando o assunto é desenvolvimento em camadas de rede, escalabilidade, desempenho, produtividade e o mais importante, concorrência. O próprio Rob Pike declarou que “Go foi projetado para tratar de um conjunto de problemas de engenharia de software a que estávamos expostos na construção de grandes softwares de servidor”.

Go teve influências de diversas linguagens de programação e paradigmas diferentes, dentre elas: Alef, APL, BCPL, C, CSP, Limbo, Modula, Newsqueak, Oberon, occam,Pascal, Smalltalk e Cristal, percebe-se que utilizaram do que tinham de melhor e criou algo novo e enxuto, com o mínimo necessário para resolver os problemas propostos, sem perder sua simplicidade. Acredito que isto podemos chamar de inovação. Go inovou ao quebrar os paradigmas de linguagens e implementar algo novo de forma simples e muito poderosa.

package mainimport "fmt"func main() {
    fmt.Println("Hello all folks!")
}

Menos é exponencialmente mais

A equipe de desenvolvedores do Go dizem que sua criação é uma tentativa de tornar os programadores mais produtivos. Melhorando o processo de desenvolvimento de software no Google. O primeiro objetivo foi criar uma linguagem melhor para enfrentar os desafios da simultaneidade escalável, ou seja software que lida com muitas preocupações simultaneamente, um exemplo seria a coordenação de mil servidores back-end enviando tráfego de rede todo o tempo.

Manter a linguagem Go pequena permite objetivos mais importantes. Ser pequeno torna o Go mais fácil de aprender, mais fácil de entender, mais fácil de implementar, mais fácil de reimplementar, mais fácil de depurar, mais fácil de ajustar e mais fácil de evoluir. Fazer menos permite mais. É uma expressão utilizada pela equipe de desenvolvimento do Go: “Do Less. Enable More” seria o equilíbrio entre os universo de problemas existentes e o que Go poderá ajudar a resolver bem tais problemas. Go explicitamente não foi projetado para resolver todos os problemas, em vez disso fizeram o suficiente para que possamos criar as próprias soluções personalizadas com facilidade, mas deixando bem claro que Go não pode fazer tudo.

Alvoroço na comunidade Go

Foram deixadas de fora diversas características das linguagens modernas,contrariando e indo em direção oposta das outras linguagens atuais, algumas funcionalidades como: o uso de declarações de imutabilidade, tipos de dados de correspondência de padrões, generics, tratamento de exceção, Herança, programação genérica,assertion e sobrecarga de métodos e diversos outros pontos. Todos os recursos acima foram criticados e apontados para os criadores de Go, que responderam: “Essas omissões foram simplificações que contribuíram e contribuem para a força de Go”. Há muitas coisas na linguagem e bibliotecas Go que diferem das práticas modernas, foi uma decisão da equipe de desenvolvimento do Go: “às vezes vale a pena tentar uma abordagem diferente”.

Todos estão convidados a ajudar e contribuir se assim desejar. Os interessados podem abrir propostas para novos recursos e tudo relacionado ao ecossistema da linguagem. O código fonte de Go está disponível no GitHub . A documentação sobre como você pode contribuir com o idioma é fornecida aqui.

Concorrência é diferente de paralelismo

Uma das famosas frases é: “Concorrência é sobre lidar com muitas coisas ao mesmo tempo. Paralelismo é fazer muitas coisas ao mesmo tempo”.Concorrência é a composição de cálculos de execução independente. Concorrência é uma maneira de estruturar software, e definitivamente não é paralelismo embora permita o paralelismo.

Se você tiver apenas um processador, seu programa ainda pode ser concorrente, mas não pode ser paralelo. Por outro lado, um programa concorrente bem escrito pode ser executado de forma eficiente em paralelo em um multiprocessador. Sugiro dar uma conferida neste vídeo de uma palestra do Rob Pike “Concorrência não é Paralelismo”.

Concorrência em Go é muito poderosa e também simples de codar está foi a intensão dos engenheiros que desenvolveram Go. A resolução de muitos problemas é bem mais eficiente utilizando concorrência e este é o poder de Go, por isto, se tornou um Deus quando o assunto é concorrência. Devido a isto, problemas englobados neste universo serão resolvidos com muita eficiência e o mais importante, com muito pouco recurso computacional.

O exemplo abaixo é um clássico quando nos referimos a concorrência, quando queremos balancear CPU e E/S usamos este parttern Fan-out.

O que é Fan-out ?

São múltiplas funções podem ler do mesmo canal até que esse canal seja fechado, isso é chamado de fan-out . Isso fornece uma maneira de distribuir o trabalho entre um grupo de trabalhadores para paralelizar o uso da CPU e E/S.

/*
* Example Worker
* @package     main
* @author      @jeffotoni
 */

// In this example we'll look at how to implement
// a _worker pool_ using goroutines and channels.
package main

import "fmt"
import "time"

// Here's the worker, of which we'll run several
// concurrent instances. These workers will receive
// work on the `jobs` channel and send the corresponding
// results on `results`. We'll sleep a second per job to
// simulate an expensive task.
func worker(id int, jobs <-chan int, results chan<- int) {

    for j := range jobs {

        fmt.Println("worker", id, "started  job", j)

        time.Sleep(time.Second)

        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {

    // In order to use our pool of workers we need to send
    // them work and collect their results. We make 2
    // channels for this.
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // This starts up 3 workers, initially blocked
    // because there are no jobs yet.
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // Here we send 5 `jobs` and then `close` that
    // channel to indicate that's all the work we have.
    for j := 1; j <= 5; j++ {
        jobs <- j
    }

    close(jobs)

    // Finally we collect all the results of the work.
    for a := 1; a <= 5; a++ {
        <-results
    }
}

Pontos positivos de Go:

• Não possui Generics;

• Não possui sobrecarga do operador;

• Não possui aritmética de ponteiros;

• Não é explícito o gerenciamento de Threads;

• Possui inferência de tipos;

• As Dependências são claras;

• A sintaxe é limpa;

• A semântica é clara;

• A composição e não herança;

• GC Nativo (Garbage collector);

• Possui Goroutines;

• Suporte nativo a programação concorrente;

• Funções de Primeira Classe (podemos passar funções como parâmetros);

• Multiplataforma;

• Open Source;

• Curva de Aprendizado muito baixa ou seja fácil de aprender;

• Altamente produtivo;

• Resolve problemas de escalabilidade;

• Pode diminui seus custos de servidores drasticamente;

• Diversos problemas pensados na perspectiva Go torna-se muito mais fáceis de tratar e resolvê-los;

• Possui somente 25 Palavras reservadas;

• Multi-paradigma: concorrente, funcional, imperativa, orientada a objeto;

• Memory Safe.

Sabemos que diversos pontos acima serão criticados, mas na prática e com o tempo percebemos que todas as simplificações omitidas tornaram Go uma linguagem ainda mais poderosa. Para projetos simples ou complexos Go sempre será uma excelente alternativa, pois torna tudo mais simples e enxuto, fácil de codar e dar manutenção.

Go é amor ❤

Um dos principais objetivos da linguagem de programação Go é tornar a simultaneidade mais simples, rápida e eficiente.

Com certeza, as Goroutines são uma das principais características do Go e são uma das principais razões pelas quais o Go é tão eficiente na execução de tarefas em paralelo.

Quando criamos apis em Go utilizando net/http e recebemos uma porrada de requisições o que o pkg net/http usa? Se sua resposta for Goroutines você está correto 😍.

Eu evito o termo "threads leves", isto gera uma confusão para quem está iniciando ou tentando entender o que são Goroutines. Embora seja verdade que as Goroutines são semelhantes às "threads leves" em outros sistemas, Go usa uma implementação diferente que é otimizada para o contexto do Go. Portanto, pode ser melhor explicar as Goroutines em termos de como elas funcionam no Go que eu acredito que irá facilitar ainda mais o seu entendimento.

Em vez de dizer que as Goroutines são "threads leves", podemos dizer que as Goroutines são unidades leves de concorrência que são executadas em uma única thread de execução ou em várias dependendo de como o runtime Go decide gerenciá-las. Isso significa que o Go pode executar muitas Goroutines simultaneamente em uma única thread ou diversas threads.

As Goroutines são gerenciadas pelo runtime do Go e não pelo sistema operacional subjacente. Isso significa que as Goroutines são muito mais leves e eficientes do que as threads tradicionais do sistema operacional e que o Go pode gerenciá-las de forma mais eficaz para obter o máximo desempenho e escalabilidade.

Um dos objetivos das Goroutines em Go é permitir que você escreva programas concorrentes de maneira fácil e eficiente. Isso significa que você pode ter várias Goroutines em execução simultaneamente, cada uma executando uma tarefa diferente, sem precisar se preocupar com bloqueios de recursos, espera ativa ou outros problemas comuns de programação concorrente.

Para criar uma Goroutine em Go, você pode simplesmente adicionar a palavra-chave "go" antes de uma chamada de função.
Por exemplo, considere o seguinte código:

package main
func myFuncJeff() {
    // seu gode aqui.
}
func main() {
    // inicia a Goroutine
    go myFuncJeff()
    // pode colocar algo aqui
}

Goroutines são leves e tiram proveito de todo o poder de processamento disponível. Goroutines existe apenas no espaço virtual do tempo de execução Go e não no sistema operacional.

Goroutine é um método/função que pode ser executado independentemente junto com outras goroutines. Cada atividade simultânea na linguagem Go é geralmente denominada Goroutine.

Go é uma linguagem multiparadigma e dentre os mais relevantes é o paradigma concorrente. Um dos pontos mais relevantes e importantes na linguagem Go é o trabalho com concorrência, Go inovou ao quebrar o modelo tradicional de threads e sua forma de utilização ao criar um novo modelo, as goroutines. As goroutines são responsáveis por realizar execuções em Go de forma assíncrona. São muito poderosas e uma simples máquina de 1G de Ram e 1CPU poderá subir milhares de goroutines.

Em Go as Goroutines contribuem para tornar a simultaneidade fácil de usar. As goroutines podem ser muito baratas: eles têm pouca sobrecarga além da memória para a pilha, que é apenas alguns kilobytes.

Para tornar as pilhas pequenas, o tempo de execução de Go usa pilhas redimensionáveis e delimitadas. Uma goroutine recém lançada recebe alguns kilobytes, o que é quase sempre suficiente. Quando não é, o tempo de execução aumenta (e encolhe) a memória para armazenar a pilha automaticamente, permitindo que muitos goroutines vivam em uma quantidade modesta de memória.

A sobrecarga da CPU tem em média três instruções baratas por chamada de função. É prático criar centenas de milhares de goroutines no mesmo espaço de endereço. Se goroutines fossem apenas threads, os recursos do sistema acabariam em um número muito menor.

package main
func enviarEmail(...string) {
    // Código para enviar o e-mail
}
func enviarParaFila(mensagem string) {
    // Código enviando para fila
}
func main() {
    // goroutine envia email
    go enviarEmail("jeff@gmail.com", "meu email")
    // goroutine envia para fila
    go enviarParaFila("Mensagem para a fila")
    // Faça alguma outra coisa aqui
}

Neste exemplo, criamos duas funções, enviarEmail e enviarParaFila, que simulam o envio de um e-mail e o envio de uma mensagem para a fila, respectivamente. Em seguida, na função main(), iniciamos duas Goroutines diferentes, uma para enviar um e-mail e outra para enviar uma mensagem para a fila.

Observe que estamos usando a palavra-chave go antes de cada chamada de função para iniciar uma Goroutine separada para cada tarefa. Isso significa que o programa continuará a ser executado normalmente, sem esperar que o envio de e-mail ou a mensagem da fila sejam concluídos.

O design de Go foi fortemente influenciado pelo artigo de C.A.R. Hoare 1978 “Communicating sequential processes” (Comunicação de processos sequenciais).

Simultaneidade nas ideias do CSP

Um dos modelos mais bem-sucedidos para fornecer suporte linguístico de alto nível para concorrência é o Hoare’s Communicating Sequential Processes, ou CSP, Occam e Erlang são duas línguas bem conhecidas que derivam de CSP. As primitivas de concorrência de Go derivam de uma parte diferente da árvore genealógica cuja principal contribuição é a poderosa noção de canais como objetos de primeira classe. A experiência com várias linguagens anteriores mostraram que o modelo CSP se encaixa bem em uma estrutura de linguagem procedural.

A maior diferença entre Go e o modelo CSP, além da sintaxe, é que o Go modela os canais de comunicação simultânea explicitamente como canais, enquanto os processos da linguagem de Hoare enviam mensagens diretamente uns aos outros, semelhante ao Erlang.

Bem para chegar neste resultado Go novamente sofreu críticas do modelo adotado. Go incorpora uma variante do CSP (Comunicação de processos sequenciais) é uma linguagem formal para descrever padrões de interação em sistemas concorrentes com canais de primeira classe. Não foi adotada uma abordagem de gravação única para valorizar a semântica no contexto da computação concorrente como é feita no Erlang, ao invés disto adotaram algo prático e que resultou em algo poderoso, permitindo programação simultânea simples e segura, mas não proíbe programação incorreta. E o lema criado foi: “Não se comunique compartilhando memória, compartilhe memória comunicando-se”.

A simplicidade e o suporte para concorrências oferecidas por Go gera robustez.

package main
import (
    "fmt"
    "net/http"
    "time"
)
func getSites(url string) {
    resposta, err := http.Get(url)
    if err != nil {
        fmt.Printf("Erro ao ler %s: %s\n", url, err)
        return
    }
    defer resposta.Body.Close()
    fmt.Printf("%s lido com sucesso\n", url)
}
func main() {
    // URLs que iremos ler
    urls := []string{
        "https://www.google.com",
        "https://www.facebook.com",
        "https://www.github.com",
        "https://www.linkedin.com",
    }
    // Goroutine separada para ler cada URL
    for _, url := range urls {
        go getSites(url)
    }
    // Faça alguma outra coisa aqui
        // ...
    time.Sleep(5 * time.Second)
}

Neste exemplo, definimos uma função getSite que usa o pacote net/http para fazer uma solicitação HTTP a um site específico e ler a resposta. Em seguida, na função main(), definimos uma lista de URLs que queremos ler e iniciamos uma Goroutine separada para ler cada URL.

Observe que estamos usando um loop for para percorrer a lista de URLs e iniciar uma Goroutine separada para cada URL usando a palavra-chave go. Isso significa que o programa continuará a ser executado normalmente, sem esperar que cada solicitação HTTP seja concluída.

Para dar tempo às Goroutines para que elas possam fazer o seu trabalho, usamos a função time.Sleep() para suspender a execução do programa por um curto período de tempo. Neste exemplo, usamos um atraso de 5 segundos para permitir que as Goroutines terminem de executar.

Vamos fazer o mesmo código agora usando sync.WaitGroup para sincronizar as nossas Goroutines e ficar ainda melhor o controle sobre elas.

package main
import (
    "fmt"
    "net/http"
    "sync"
)
func getSite(url string, wg *sync.WaitGroup) {
    // Sinalize o WaitGroup quando a Goroutine terminar
    defer wg.Done()

    resp, err := http.Get(url)
    if err != nil {
        fmt.Printf("Erro ao ler %s: %s\n", url, err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("%s lido com sucesso\n", url)
}
func main() {
    // URLs que iremos ler
    urls := []string{
        "https://www.google.com",
        "https://www.facebook.com",
        "https://www.github.com",
        "https://www.linkedin.com",
    }
    // Crie um WaitGroup 
        // para sincronizar as Goroutines
    var wg sync.WaitGroup
    for _, url := range urls {
        // Adicione WaitGroup para cada Goroutine
        wg.Add(1)
        // Passe o WaitGroup como um ponteiro
        go getSite(url, &wg)
    }
    // Espere até que todas as Goroutines terminem
    wg.Wait()
        fmt.Println("done")
}

Usando o WaitGroup, podemos garantir que todas as Goroutines terminem de executar antes que o programa continue. Isso é especialmente útil quando queremos que o programa termine apenas quando todas as tarefas simultâneas sejam concluídas.

Concorrência é diferente de Paralelismo

Uma das famosas frases é: “Concorrência é sobre lidar com muitas coisas ao mesmo tempo. Paralelismo é fazer muitas coisas ao mesmo tempo”. Concorrência é a composição de cálculos de execução independente. Concorrência é uma maneira de estruturar software, e definitivamente não é paralelismo embora permita o paralelismo.

Se você tiver apenas um núcleo físico em seu processador, seu programa ainda pode ser concorrente, mas não pode ser paralelo. Por outro lado, um programa concorrente bem escrito pode ser executado de forma eficiente em paralelo em processador que possua mais de um núcleo físico. Sugiro dar uma conferida neste vídeo de uma palestra do Rob Pike “Concorrência não é Paralelismo”.

Concorrência em Go é muito poderosa e também simples de godar, está foi a intensão dos engenheiros que desenvolveram Go. A resolução de muitos problemas é bem mais eficiente utilizando concorrência e este é o poder de Go, por isto, se tornou um Deus quando o assunto é concorrência. Devido a isto, problemas englobados neste universo serão resolvidos com muita eficiência e o mais importante, com muito pouco recurso computacional.

Quer aprofundar ainda mais sobre concorrência? Só entrar neste link. Quer testar e visualizar alguns exemplos? Click Aqui.

Goroutine é um tópico muito extenso, cheio de detalhes e muitas situações interessantes. Então requer que futuramente façamos um post somente sobre isso para que seja tratado com o devido cuidado e atenção.

Confira um exemplo simples.

package main
import (
    "fmt"
    "time"
)
func main() {
    go func(){fmt.Println("oi sou uma goroutine1!")}()
    go func(){fmt.Println("oi sou uma goroutine2!")}()
    go func(){fmt.Println("oi sou uma goroutine3!")}()
    fmt.Println("Olá, estamos testando as goroutines em Go!")  
    time.Sleep(time.Second)
}

Canais

Os canais em Go são uma forma de sincronizar a comunicação entre Goroutines e compartilhar dados. Eles permitem que uma Goroutine envie dados para outra Goroutine de maneira segura e eficiente, sem a necessidade de usar bloqueios ou semáforos.

Os canais são criados usando a função make() e podem ser usados para enviar ou receber valores de um determinado tipo. Os canais podem ser definidos com uma capacidade opcional, que especifica quantos valores podem ser armazenados no canal antes que ele comece a bloquear. Se a capacidade não for especificada, o canal terá uma capacidade de zero, o que significa que ele pode armazenar apenas um valor por vez.

Para enviar um valor para um canal, usamos a sintaxe <-, como em canal <- valor. Para receber um valor de um canal, usamos a mesma sintaxe, mas invertida, como em valor <- canal. Quando usamos a sintaxe <- sem uma variável à esquerda ou à direita, ele é usado para bloquear a execução da Goroutine até que um valor seja enviado ou recebido pelo canal.

package main
import "fmt"
func produtor(canal chan<- int) {
    for i := 0; i < 10; i++ {
        canal <- i // Envia um valor para o canal
    }
    close(canal) // Fecha o canal
}
func consumidor(canal <-chan int) {
    for valor := range canal { // Itera sobre os valores recebidos do canal
        fmt.Println(valor) // Exibe o valor recebido
    }
}
func main() {
    // Cria um canal sem capacidade definida
    canal := make(chan int)
    // Goroutine do produtor para enviar valores para o canal
    go produtor(canal)
    // Goroutine do consumidor para receber os valores do canal
    consumidor(canal)
}

Neste exemplo, temos duas Goroutines diferentes: uma produtora e uma consumidora. A Goroutine produtora envia valores para o canal, enquanto a Goroutine consumidora os recebe e os exibe na tela.

Observe que estamos usando a palavra-chave chan para definir o tipo do canal. No caso deste exemplo, estamos usando chan int, que significa que estamos criando um canal que pode ser usado para enviar ou receber valores inteiros.

Também usamos as palavras-chave <-chan e chan<- para especificar se o canal deve ser usado para enviar ou receber valores. No caso da Goroutine produtora, estamos usando canal chan<- int, o que significa que estamos criando um canal que pode ser usado apenas para enviar valores inteiros. Na Goroutine consumidora, estamos usando canal <-chan int, o que significa que estamos criando um canal que pode ser usado apenas para receber valores inteiros.

Ao chamar a função close() no canal na Goroutine produtora, estamos sinalizando que não há mais valores para serem enviados pelo canal. Isso faz com que a função range na Goroutine consumidora saia do loop quando todos os valores tiverem sido recebidos.

Vamos reforçar o conceito: Um canal é um objeto de comunicação usado pelas goroutines e que tem o papel fundamental na comunicação entre as goroutines. Tecnicamente, um canal é a transferência de dados no qual os dados podem ser passados ou lidos . Assim, uma goroutine pode enviar dados para um canal, enquanto outras goroutines podem ler os dados do mesmo canal, como uma fila. Os canais é a forma mais segura de comunicação na linguagem Go. Existe outras formas de compartilhar dados em Go, não tão eficientes quanto os canais a equipe que desenvolveu Go decidiram não fechar as possibilidades e é possível compartilhar dados sem usar canais.

Declarando um Canal sem buffer e com buffer

type Promise struct {
  Result chan string
  Error  chan error
}
var (
  ch1  = make(chan *Promise)  // received a pointer from the structure
  ch2  = make(chan string, 1) // allows only 1 channels
  ch3  = make(chan int, 2)    // allows only 2 channels
  ch4  = make(chan float64)   // has not been set can freely receive
  ch5  = make(chan []byte)    // by default the capacity is 0
  ch6  = make(chan bool, 1)   // non-zero capacity
  ch7  = make(chan time.Time, 2)
  ch8  = make(chan struct{}, 2)
  ch9  = make(chan struct{})
  ch10 = make(map[string](chan int)) // map channel
  ch11 = make(chan error)
  ch12 = make(chan error, 2)
  // receives a zero struct
  ch14 <-chan struct{}
  ch15 = make(<-chan bool)          // can only read from
  ch16 = make(chan<- []os.FileInfo) // can only write to// holds another channel as its value
  ch17 = make(chan<- chan bool) // can read and write to
)

Recebendo valores no canal

func main() {
  ch2 <- "okay"
  defer close(ch2)
  fmt.Println(ch2, &ch2, <-ch2)
  ch7 <- time.Now()
  ch7 <- time.Now()
  fmt.Println(ch7, &ch7, <-ch7)
  fmt.Println(ch7, &ch7, <-ch7)
  defer close(ch7)
  ch3 <- 1 // okay
  ch3 <- 2 // okay
  // deadlock // ch3 <- 3 // does not accept any more 
  // values, if you do it will error : deadlockdefer close(ch3)
  fmt.Println(ch3, &ch3, <-ch3)
  fmt.Println(ch3, &ch3, <-ch3)
  ch10["lambda"] = make(chan int, 2)
  ch10["lambda"] <- 100defer close(ch10["lambda"])
  fmt.Println(<-ch10["lambda"])
}

Um pequeno exemplo de goroutine utilizando canais.

Exemplo1:

package main
import "fmt"
func goroutine(c chan string) {
    fmt.Println("Eu sou um canal: " + <-c + "!")
}
func main() {
  fmt.Println("start goroutine!")
  c := make(chan string)
  go goroutine(c)
  c <- "jeffotoni"
}

Exemplo2:

    package main
    import (
        "fmt"
        "time"
    )
    // escrevendo no canal
    func write(ch chan int) {
        for i := 0; i < 5; i++ {
            ch <- i
            fmt.Println("escrever:", i, "to ch")
        }
        close(ch)
    }
    func main() {
        // channel com buffer
        ch := make(chan int, 2)
        // goroutine
        go write(ch)
        //aguarde um pouco
        time.Sleep(1 * time.Second)
        // listando o canal
        for v := range ch {
            fmt.Println("ler", v, "from ch")
            time.Sleep(2 * time.Second)
        }
    }

Neste exemplo, estamos definindo uma variável chamada ch que é um canal que só pode ser usado para receber valores do tipo struct{}. Usamos a palavra-chave <-chan para especificar que esse canal só pode ser usado para receber valores.

Confira o código abaixo:

package main
import "fmt"
func main() {
    // Cria um canal sem capacidade definida
    ch := make(chan struct{})
    // Inicia uma Goroutine para enviar um valor para o canal
    go func() {
        ch <- struct{}{} // Envia um valor para o canal
    }()
    // Recebe um valor do canal e exibe uma mensagem
    <-ch
    fmt.Println("Valor recebido do canal")
}

Select

O select é uma estrutura de controle em Go que permite que você monitore vários canais simultaneamente e execute a primeira operação que estiver pronta. Isso permite que você escreva código conciso e eficiente que responde a eventos de vários canais ao mesmo tempo.

package main
import (
    "fmt"
    "time"
)
func enviarMesg(canal chan<- string, mensagem string, atraso time.Duration) {
    // Espera por um período de tempo aleatório
    time.Sleep(atraso)
    // Envia a mensagem para o canal
    canal <- mensagem
}
func main() {
    // Cria dois canais sem capacidade definida
    canal1 := make(chan string)
    canal2 := make(chan string)
    // Inicia duas Goroutines separadas para enviar mensagens para os canais
    go enviarMesg(canal1, "Mensagem para o canal 1", time.Second*2)
    go enviarMesg(canal2, "Mensagem para o canal 2", time.Second*1)
    // Use o select para receber a primeira mensagem que estiver pronta
    select {
    case msg1 := <-canal1:
        fmt.Println("Mensagem recebida do canal 1:", msg1)
    case msg2 := <-canal2:
        fmt.Println("Mensagem recebida do canal 2:", msg2)
    }
}

Neste exemplo, temos duas Goroutines diferentes que enviam mensagens para dois canais diferentes. Usando o select, estamos monitorando os dois canais e exibimos a primeira mensagem que chega em um deles.

Observe que estamos usando a sintaxe <- para receber valores dos canais dentro dos casos do select. O select aguardará até que um dos casos esteja pronto, o que significa que uma mensagem foi recebida de um dos canais.

Além disso, estamos usando o time.Sleep() na função enviarMsg() para simular um atraso aleatório antes de enviar a mensagem para o canal. Isso é feito para demonstrar que a mensagem enviada ao canal mais rapidamente pode não ser a primeira a ser recebida devido aos atrasos.

O select é uma ferramenta poderosa em Go que pode ser usada para escrever código eficiente que monitora vários canais ao mesmo tempo. É particularmente útil para lidar com eventos assíncronos e permitir que o programa execute várias tarefas simultaneamente.

Espero ter colaborado para melhor entendimento quando o assunto é Goroutine.

Um outro assunto complementar e importante é "Workloads: CPU-Bound e IO-Bound" recomendo a leitura para entender ainda mais.

Aqui você irá encontrar mais exemplos:
manual Go em: gobootcamp.jeffotoni
Exemplos diversos de Goroutines em: goexample

Em Go teremos um arsenal para trabalhar com goroutines e gerenciar concorrências mas sem perder a simplicidade, legibilidade e produtividade.

Go é amor ❤

Iniciando em Go❤️

Antes de iniciarmos, é importante salientar que linguagens de programação são ferramentas e como toda boa ferramenta temos que saber quais momentos usa-las. Existem cenários e problemas que só são resolvidos com linguagens específicas e existe outros universos de problemas que temos centenas ou milhares de linguagens que resolvem de alguma forma o mesmo problema. Então como um bom profissional quanto mais ferramentas souber para resolver problemas melhor será para sua carreira profissional🤩.

A linguagem Go em seu universo de possibilidades é uma linguagem de uso comum não gosto muito deste termo fica parecendo que ela é tipo uma bala de prata e resolve todos os problemas mas que na verdade não, Go nasceu por um propósito e resolve problemas do universo web e aproveitar a nova tecnologia de multicores em servidores, bem este era o propósito inicial 😂.

História do projeto Go

“Robert Griesemer, Rob Pike e Ken Thompson começaram a esboçar as metas para uma nova linguagem no quadro branco em 21 de setembro de 2007. Em poucos dias, as metas se estabeleceram em um plano para fazer algo e uma ideia justa do que seria. O design continuou a tempo parcial em paralelo com o trabalho não relacionado. Em janeiro de 2008, Ken começou a trabalhar em um compilador para explorar ideias; ele gerou código C como sua saída. Em meados do ano, a linguagem se tornou um projeto em tempo integral e se estabeleceu o suficiente para tentar um compilador de produção. Em maio de 2008, Ian Taylor começou de forma independente em um front-end GCC para Go usando as especificações preliminares. Russ Cox entrou no final de 2008 e ajudou a mover a linguagem e as bibliotecas do protótipo para a realidade.”

Go tornou-se um projeto de código aberto público em 10 de novembro de 2009 🥳. Inúmeras pessoas da comunidade contribuíram com ideias, discussões e códigos.

“Existem agora milhões de programadores Go “Gophers” em todo o mundo, e há mais a cada dia. O sucesso de Go excedeu em muito as expectativas.”

Por que criaram uma nova linguagem

“Go nasceu da frustração com os idiomas e ambientes existentes para o trabalho que estávamos fazendo no Google. A programação havia se tornado muito difícil e a escolha das línguas era parcialmente culpada. Era preciso escolher entre compilação eficiente, execução eficiente ou facilidade de programação; todos os três não estavam disponíveis no mesmo idioma principal. Os programadores que poderiam escolher facilidade em vez de segurança e eficiência, mudando para linguagens tipadas dinamicamente, como Python e JavaScript, em vez de C++ ou, em menor grau, Java.”

“Go tratou dessas questões tentando combinar a facilidade de programação de uma linguagem interpretada e dinâmica com a eficiência e segurança de uma linguagem compilada estaticamente. Também pretendia ser moderno, com suporte para computação em rede e multicore. Finalmente, trabalhar com Go pretende ser rápido : deve demorar no máximo alguns segundos para construir um grande executável em um único computador.”

Nasce uma nova linguagem Go, para atender as novas necessidades e resolver problemas aproveitando o máximo possível do poder computacional. E é claro criando o seu mascote para a os milhares de gophers que viram a surgir a partir deste momento.

Site Oficial

Para iniciarmos em Go❤️ vamos dar alguns passos para trás, vamos começar toda nossa trajetória conhecendo o site oficial da lang esta é a página oficial golang.org, aqui encontraremos todas informações que poderíamos saber sobre Go e muito mais. Aqui temos os docs, packages, blog e nosso queridinho play.golang.org, specs da lingugem, download, tour em Go e muito mais.

O site oficial aparentemente parece pequeno mas ele é muito completo e grande. Então temos praticamente tudo que precisamos saber de Go para iniciarmos nosso aprendizado nesta linguagem que é um fenômeno.

Onde Inicio no Site

Vou criar uma linha de raciocínio para que possamos entender Go de forma mais prática possível.

Antes de instalar Go, ou rodar Go pelo play, vamos da uma passada em algumas partes do doc para que possamos entender um pouco da história do Go e por que nasceu uma nova linguagem neste universo de milhares de linguagens de programação.

Effective Go

Este link é o primeiro que todos deveriam ler antes de tudo.
Effective Go❤️ neste site está todo material que precisa para ter uma boa noção da linguagem Go: Estrutura de controle, funções, Programação concorrente usando Goroutines, métodos, Maps e muito mais.

Um tour de Go

Este link seria o segundo mais importante na minha hierarquia para aprendermos Go.
Tour Go❤️ neste site você irá conseguir testar e da uma passada em algumas das funcionalidades da linguagem Go 😱 isto mesmo tudo pelo browser sem precisar instalar nadinha na máquina.

Playground Go

Aqui é muito lindo, você não precisa instalar nadinha na máquina para executar algo rapidamente em Go, basta entrar no play.golang.org

Play Go❤️ neste site você irá conseguir executar Go 😱 isto mesmo não precisamos instalar nada por enquanto, da para executar tudo pelo browser e ir conhecendo a sintaxe da linguagem e aprendendo.

Perguntas mais Frequentes

Este link seria o nosso terceiro passo, acredito que agora tem diversas dúvidas, geradas pelo Effective Go e pelo Tour que fez.
Faq❤️ é aqui que irá tirar algumas horas para esta leitura não precisa ser tudo de uma vez é claro, mas é necessário que leia. Esta página é essencial para organizar suas ideias e entender realmente um pouco mais sobre Go🥰.

Esta é uma das maiores páginas e requer mais leitura, mas esta página é essencial para o melhor entendimento sobre a linguagem Go, o tempo que irá gastar lendo esta página com certeza irá te economizar horas de trabalho.

Pacotes nativos Go

Este link seria para que possa da uma passada e entender como são organizados e como é a documentação das funções, libs, pkgs que possamoms utilizar na linguagem Go. Este é um dos pontos fortes da linguagem, ela é muito completa para o desenvolvimento web para servidores.
Pkg❤️ escolhi aqui o pkg string para que possa da uma conferida como é a formatação da documentação da linguagem e já com exemplos podendo ser executados pelo browser tudo para facilitar o aprendizado e entendimento🥰.

Editores e IDE

Este link é sobre as IDEs e Editores que poderá utilizar quando tiver Godando. A linguagem Go não precisa de muito para que possamos editar nossos códigos, mas temos alguns plugins interessantes para facilitar ainda mais nosso dia a dia
Editores e IDE❤️ Neste link não irá ter o Sublime e o nvim que são dois editores que uso por aqui no dia a dia, o sublime pela pesquisa do survey somente 7,7% utilizam sublime e vim 14% o nvim é um plugin que irá usar no vim. O queridinho e adotado pelo equipe Go é o VsCode com 41% de adesão.

Pontos Fortes da linguagem Go

Antes de fazermos nosso famigerado “Hello World” vamos mostrar alguns pontos fortes da Linguagem, vamos fazer uma prévia dos pilares e características da linguagem Go.

3 Pilares

Temos alguns pilares bem definidos em Go, isto irá ajuda-lo a clarear ainda mais seu horizonte quanto o assunto é Go.

• Simplicidade

• Legibilidade

• Produtividade

Isto torno-se ao longo dos anos algo tão padrão para quem está desenvolvendo no universo Go que soa como poesia para os ouvidos. Sabemos que go é uma tentativa de juntar dois mundos distintos, o mundo das linguagens compiladas com as linguagens interpretadas, em 2007 nasceu a ideia e com objetivo de criar uma nova linguagem de programação.

Características principais

Em Go temos algumas características marcantes da linguagem que torna ela ainda mais poderosa para desenvolvimento de aplicações web para servidores.

• Somente 25 keywords

• Curva de aprendizado baixa

• Compilada estaticamente

• Multiplataformas agora com suporte a RISC-V

• Paradigma Concorrente

• Tipagem Estática

• Retrocompatibilidade

Todos estes pontos torna a linguagem ainda mais interessante, a equipe de engenheiros que desenvolveu a linguagem fizeram um excelente trabalho ou melhor veem fazendo, Go é simplesmente fantástico alguns não gostam do seu designer mas é compreensível mais de 20 anos desenvolvendo em paradigmas OO e Funcional como se não houvesse vida em outro planeta é compreensível 😂.

Instalando Go

Este é o momento que todos esperávamos, colocar a mão na massa e instalar local, no site oficial não tem como errar, não tem nada mais simples que instalar o Go em sua máquina para que possa programar em Go. Aproveitando e deixando claro que: Não precisamos instalar Go no servidor, isto mesmo que leu, em seu servidor seja ele qual for, On-premises, um Ec2 da Aws ou um pod no k8s seja ele no Gke, ou k8s da DigitalOcean, ou seja em ECS ou EKS, seja um serverless ou em algum servidor de hospedagem de sua preferência, o que irá precisar é do binário seja em uma imagem docker por exemplo ou não. Isto é um dos pontos fortes do Go, não precisamos levar tralhas para o servidor este é um dos grande benefícios de utilizar Go em aplicações web em servidores e foi por isto que Go ficou conhecido como a linguagem dos Containers😍.

Sabendo de tudo isto vamos a instalação de Go e vamos ver o tão quanto ela é complexa 😜😜, brincadeirinha… 😂

Install Go neste link terá o passo a passo de como instalar em diversos Sistemas Operacionais mas vou deixar aqui a instalação no Linux.

Instalação no Linux

Se você tiver uma versão anterior do Go instalada, certifique-se de removê-la antes de instalar outra.

1. $ sudo rm -rf /usr/local/go

2. Baixe o arquivo clicando aqui go1.15.6 e extraia-o em /usr/local

3. $ sudo tar -C /usr/local -xzf go1.15.6.linux-amd64.tar.gz

4. Adicione /usr/local/go/bin à PATHvariável de ambiente.

5. $ export PATH=$PATH:/usr/local/go/bin

6. Para deixar o que fizemos acima global, ou seja toda vez que for entrar em seu terminal “go” seja executado você pode fazer isso adicionando a seguinte linha que mostrei acima ao seu $HOME/.profile ou /etc/profile (para uma instalação em todo o sistema) ou em seu bash ou o que estiver usando em seu ambiente Linux.

7. Nota: As alterações feitas em um arquivo de perfil podem não se aplicar até a próxima vez que você efetuar login em seu computador. Para aplicar as alterações imediatamente, basta executar os comandos do shell diretamente ou executá-los a partir do perfil usando um comando como source $HOME/.profile.

8. Verifique se você instalou o Go abrindo um prompt de comando e digitando o seguinte comando:

go version

Se tudo correr bem você irá visualizar: “go version go1.15.6 linux/amd64” lindo, simplesmente lindo pode falar, muito simples.

Hello World

Agora sim chegou a hora de nossos primeiros “hello world” utilizando Go.

Não tem segredo, podemos utilizar de qualquer editor que vimos acima e irmos para cima. Em Go não precisamos compilar quando estamos godando podemos simplesmente executar nossos programas sem precisar transforma-los em binários ou seja compilar.

go run main.go

Abaixo está nosso primeiro hello world, e basta salvar o arquivo com a extensão .go e coloque o nome de “_main.go_” depois basta executar ele com o comando “go run main.go”, em nosso exemplo chamei o arquivo de “main.go”

package main

func main() {

  println("Meu primeiro Hello World")

}

package main

import(
    "fmt"
)

func main() {

  fmt.Println("Meu primeiro Hello World")

}

$ go run main.go

Este nosso hello world é a menor estrutura que podemos montar para da saída no terminal.

Para ficar um pouquinha mais claro quando usarmos a função println temos que saber que que ela é uma função embutida (no tempo de execução) que pode eventualmente ser removida, enquanto o fmt pacote está na biblioteca padrão, que irá persistir.

go build

Agora vamos transformar em binário vamos compilar e para isto vamos utilizar o “go build” ou “GOARCH=386 GOOS=linux go build -o myprogram main.go” estamos agora informando a arquitetura e sistema operacional que desejamos compilar nosso programa Go.

$ GOARCH=386 GOOS=linux go build -o myhello main.go

Este comando irá fazer o build ele irá gerar um “executável” um binário para ser executado em seu sistema operacional. Muito fácil não é ?😍 Eu diria muito lindo. Com este binário você irá conseguir executa-lo em sua máquina ou em qualquer servidor que tenha a mesma arquitetura e sistema operacional que tenha feito para sua compilação.

É importante frisar sempre este detalhe: “Não instalamos nada de Go em nossos servidores Web” é exatamente o que leu, não precisa instalar nadinha, só precisa do binário. ❤️ Foi devido a isto que Go ficou conhecido por ser a Linguagem dos Containers. Diz que isto não é fantástico ? 😍 Para que rode uma aplicação Web em seu servidor basta enviar o binário para ele. Uau, isto mesmo somente do binário sem precisar de levar mais nada referente ao seu projeto nadinha.

Go e Docker

Já que estamos falando do docker e dizendo que só precisamos do binário para executar nosso projeto em Go vamos apresentar como seria nossa imagem usando docker para que possamos agora utilizar Go em servidores como GKE do Google, EKS da AWS, ou k8s da DigitalOcean ou simplesmente usar com docker.

#################################################
# Dockerfile distroless
#################################################
FROM golang:1.15 as builder
WORKDIR /go/src/main
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o main main.go
RUN cp main /go/bin/main

############################
# STEP 2 build a small image
############################
FROM gcr.io/distroless/base
COPY --from=builder /go/bin/main /
CMD ["/main"]

Olha que lindo😁 pouco menos de 10 linhas. Temos uma imagem Go para que possamos compilar nosso projeto e em seguida fazemos algo parecido com Scratch porém estamos usando o distroless que é uma base enxuta bem pequena e que contém nosso binário. Desculpa mas diz que isto não é fantástico ou simplesmente lindão❤️ ?

O conceito distroless é simples ele parte do pressuposto em focarmos na nossa aplicação e menos na distribuição Linux.

Agora vamos fazer um pequeno exemplo de uma API rEST só para exemplificar nosso Dockerfile e mostrar na prática como é tão simples subirmos uma imagem docker do nosso projeto.

package main

import (
    "log"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/v1/ping", Ping)
    log.Println("Run Server 8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

func Ping(w http.ResponseWriter, r *http.Request) {
    log.Println("server ok")
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"msg":"pong"}`))
}

Agora basta fazermos build de nosso projeto com o seguinte comando:

$ docker build — no-cache -f Dockerfile -t jeffotoni/apisimplego:latest .

isto irá gerar uma imagem localmente em sua máquina e agora é só executa-la para testarmos.

$ docker run — rm — name apisimplego -p 8080:8080 jeffotoni/apisimplego

Prontinho agora é só disparar para nosso endpoint /api/v1/ping que criamos

$ curl -i localhost:8080/api/v1/ping

Diz que não é lindo 😍

Conclusão

Este post é um simples resumo para você que gostaria de aumentar seu arsenal para programação web. Espero que tenham gostado.

O canal que ocorreu a live: https://youtube.com/user/jeffotoni

O link do PDF da apresentação pode ser encontrado em: speakerdeck.com/jeffotoni