Aprenda sobre o ambiente de desenvolvimento da linguagem Golang. Dicas de instalação e uso de ferramentas para o desenvolvimento em Go. Tópicos como formatação de código, análise de código, etc. Siga o padrão de programação da linguagem Go, na maneira Golang que os arquitetos da linguagem decidiram.

Golang: Ambiente e Ferramentas de Desenvolvimento da Linguagem Go

Como Instalar a Versão Mais Atual do Go Golang no Ubuntu Linux com o Arquivo Tar Gz

# Instalação do Golang no Ubuntu Linux

## Introdução
Nesta aula, você aprenderá a instalar a versão mais atual do Golang no Ubuntu Linux. O Ubuntu utilizado neste vídeo é a versão 20.04.2 LTS.

## Verificação da Versão Atual do Golang
Antes de iniciar, verifique a versão instalada do Golang com o comando:
```bash
go version
```
Caso você tenha a versão 1.13.8 e deseje instalar uma versão mais recente (exemplo: 1.16.5), siga os próximos passos.

## Passos para Instalação

1. **Download do Golang**
   - Acesse [golang.org](https://golang.org) e vá até a seção de downloads.
   - Selecione a versão mais recente (por exemplo, `go1.16.5.linux-amd64.tar.gz`) e faça o download.

2. **Extraindo o Arquivo**
   - Vá para a pasta de downloads:
     ```bash
     cd ~/Downloads
     ```
   - Extraia o arquivo tar:
     ```bash
     sudo tar -C /usr/local -xzf go1.16.5.linux-amd64.tar.gz
     ```

3. **Remover Conflito com a Versão Anterior**
   - Verifique o caminho da versão atual instalada:
     ```bash
     which go
     ```
   - Mova o link da versão anterior:
     ```bash
     sudo mv /usr/bin/go /usr/bin/go-1.13
     ```

4. **Adicionar Novo Caminho ao `PATH`**
   - Abra o arquivo `.bashrc`:
     ```bash
     nano ~/.bashrc
     ```
   - Adicione a seguinte linha ao final do arquivo:
     ```bash
     export PATH=$PATH:/usr/local/go/bin
     ```
   - Para aplicar as mudanças, execute:
     ```bash
     source ~/.bashrc
     ```

5. **Verifique a Nova Instalação**
   - Confirme que a nova versão do Golang está funcionando:
     ```bash
     go version
     ```

## Configuração Opcional do `GOPATH`
- Edite o arquivo `.bashrc` novamente e adicione:
  ```bash
  export GOPATH=$HOME/go
  export PATH=$PATH:$GOPATH/bin
  ```

## Conclusão
Você aprendeu a instalar a versão mais atual do Golang no Ubuntu, trocar a versão anterior, ajustar o `PATH` e configurar o `GOPATH` para seu workspace. 

Se você gostou da aula, não esqueça de dar seu like e se inscrever!

Olá pessoal, bem-vindos.
Nesta aula eu vou te ensinar como instalar a versão mais atual do Golang no Ubuntu Linux.
Tá certo?
Primeiro de tudo a versão do Ubuntu que eu uso neste vídeo é a versão 20.04.2 LTS, Long Term Support.
Eu já tenho o Gol instalado mas é uma versão não mais atual.
Se eu falar Gol version, é a versão 1.13.8.
Mas eu quero instalar mais atual.
Então o que a gente vai fazer?
Vamos no site do Golang baixar o tar, arquivo tar e vamos trair e colocar no outro parte.
E a gente vai tirar o conflito entre a versão que já tem no meu sistema e a nova versão atual.
Para que ele sempre use a versão atual.
Tá certo?
Então vamos lá, primeiro vamos ao navegador.
Vai em golang.org, pica download go.
No quadradinho diz Linux, baixe o arquivo go e o número da versão.
No meu caso a mais atual quando eu gravei este vídeo é 1.16.5.
Ponto Linux traço AMD674.tar.gz.
Vou clicar para baixar.
Ele vai para minha pasta pessoal-downloads.
Certo?
Vou te mostrar aqui.
Minha pasta pessoal-downloads tem o arquivo aqui.
Vamos ao terminal e vou fazer o seguinte.
Não importa onde você faça isso, mas vou fazer a pasta de download.
Vou dar a cd-q da pasta pessoal-downloads.
Vou dar a ls-t, o arquivo aqui, gol, 1.16.5, se pude antes.
Eu vou extrair este arquivo.
Vamos lá, vamos chamar o tar.
Ele está comprimido com gzip, você poderia fazer os comandos separadamente de gzip.
Depois extrair o tar, mas pode fazer tudo ao mesmo tempo com o comandotar.
Vou usar a opção traço z, descomprimir e estar ao mesmo tempo.
Eu quero extrair, a opção x, o nome do arquivo com a opção f, vai ser gol 1.16.5.linux-amd674.tar.gz.
Mas eu não vou ainda fazer isso porque eu quero extrair na pasta diferente, não na pasta presente.
Vou adicionar a opção traços z, para ele mudar de geratório antes de extrair.
Este geratório será barra usr-local.
Note que quando eu zectei, tem permissão negada, então eu preciso usar sudo antes do comando para ele ter permissão para criar os arquivos.
Deixe-me ver, no total terminal estou no barra usr-local,
Eu vou dar o ls-traço-l por gol,
Eu tenho aqui, a pasta foi extraída,
barra usr-l, barra gol, que tem conteúdo aqui, vários arquivos,
A gente vai se interessar no barra usr-l, barra gol, barra bin,
que tem o executável do gol que a gente vai que, a gente precisa chamar esse executável,
A gente vai adicionar essa pasta bin, está dentro da pasta do gol,
ao nosso caminho, variável de ambiente path.
Mas antes disso, se você já tem uma versão já instalada pela distribuição, a gente vai ter que resolver o conflito, isso que eu vou fazer agora.
Eu vou voltar aqui na minha outra janela do terminal, eu vou falar witch-go,
e eu tenho uma versão instalada que é a versão mais, versão anterior, 1.13.8,
que está localizada na pasta usr-bin, está esse executável barra gol,
se eu dar o ls nele, usr-bin, barra gol, na verdade é um link, que aponta para outra pasta,
do gol 1.13, ponto-barraleve, barra gol, traço 1.13, barra-bin, barra gol.
Então, toda vez que eu digito gol, estou aqui, ele vai olhar lá no meu path,
e vai ver que pasta barra usr, barra-bin, está no meu path,
então ele vai localizar esse executável, quando você digita gol.
O que a gente vai fazer aqui é impedir que ele encontre a palavra gol,
o maneira de fazer isso é mover esse link, isto é, renomear para outro nome,
nesse caso eu vou usar o nome gol-1.13 para indicar a versão,
então vou falar mv, barra usr, barra-bin, barra gol, e vou renomear para barra usr-bin, barra gol, traço 1.13,
isso vai precisar de permissão de usuário root, então vou falar sudo,
e se eu dar o ls, traço l, barra usr, barra-bin, barra gol, de novo,
desculpa, deixa eu ir para o barra-bin, cd, barra usr, barra-bin, dar um ls, traço l,
agora não vai ter mais o gol, que você já notou anteriormente, quando eu rodei ls, traço l, barra usr, barra-bin, barra gol,
não existe mais, agora o que existe é o gol-1.13, eu mudei o nome de gol para gol-1.13,
então quando eu falo gol agora, ele não encontra nada, mas se eu falar gol, traço 1.13, ele funciona,
então isso vai desombiguar a versão atual e a versão anterior que vem com a distribuição,
da distribuição, então com isso já resolvido, nós podemos continuar, agora a gente vai precisar adicionar
esse executável do gol aqui da versão mais nova ao nosso path, então vamos lá, eu vou configurar
como eu uso o bash, tá o bash, em bash com o meu shell, eu vou editar o arquivo ponto bash-rc na minha pasta pessoal,
se você usar outro terminal, você tem que abrir o arquivo correspondente, por exemplo, z shell é no ponto zshrc,
então procure ver qual é o seu arquivo rc do seu shell, então vou abrir o meu arquivo na pasta pessoal,
onde quer que você define o seu path, eu já tinha aqui uma definição, eu vou adicionar o seguinte,
eu vou dar export path igual e vou dizer o dollar path, agora vou adicionar o sr,
vou adicionar o sr, vou dizer barra-loco, barra-go, barra-bin, vamos confirmar que na minha tela da direita,
da janela da direita no terminal, eu estou na pasta barra-loco, seu dls-go, tem o executável do gol aqui,
então quando eu adicionar ao meu path barra-sr, barra-loco, barra-go, barra-bin e eu falar go na linha de comando,
ele vai achar o executável na pasta go-bin, então vai dar certo, então com isso aqui eu vou salvar o meu arquivo ponto bash-rc,
não vai funcionar na mesma hora porque a gente tem que recarregar esse arquivo, os conteúdos do arquivo,
então ou você abre uma nova janela do terminal ou você tem que fazer o source,
então no meu caso eu não quero abrir nova janela, vou usar essa janela que eu já tinha,
eu vou falar source, espaço, seu diretório pessoal, barra-bash-rc no meu caso, que é o nome do arquivo do shell,
se você usar o terminal vai ser outro, com isso se eu falar go, wait-go, para ver onde aqui vem,
ele diz que esse go foi encontrado na pasta barra-sr, barra-loco, barra-go, barra-bin e barra-go,
então está acessa falar o go version, ele mostra que é a versão go 1.16.5, então funcionou corretamente,
está bom?
Agora vou falar mais uma coisa opcional sobre a variável go path e adicionar a pasta binária de modos do go,
isso é opcional, mas você pode fazer de maneira explícita, então vou fazer o seguinte,
eu quero definir um variável de ambiente chamado go path que vai apontar para o local do seu workspace do go,
workspace é a diretória onde você vai manter os seus módulos de go, e o código e tal,
por padrão vai ser o seu diretório pessoal barra-go, mas você pode modificar isso para outra coisa,
com a definição do go path, então primeiro vou abrir o meu bashrc, ponto bashrc na pasta pessoal,
vou lá para o final, você pode adicionar export, go path igual, o dollar home que vai ser o seu diretório pessoal,
barra-go que é o padrão na verdade, pasta-go no seu diretório pessoal é o padrão do go path,
que eu já disse antes, você pode mudar para qualquer diretória que você quiser, manter os módulos de go,
depois de você ter que adicionar, para você poder rodar os, por exemplo, eu baixo um módulo de go que eu quero usar como um comando,
é um programa na linha de comando, para poder rodar aquele programa eu teria que referir a pasta do go path barra-bin,
então para eu não sempre, se eu quiser rodar o comando sem precisar digitar o caminho todo,
como eu já faço com os comandos de Linux, eu posso adicionar a pasta dos binários do go ao meu path,
então eu posso dizer export path, dollar path, dois pontos, dollar go path barra-bin,
que vai ser na verdade o dollar home, barra-go, barra-bin,
já tem também uma definição se você quiser para o go path barra-bin, que pode se denominar o go-bin,
então você poderia também dizer export go-bin igual a go path barra-bin,
e em vez de falar go path barra-bin aqui no export path você fala go-bin,
pode também fazer assim, tanto faz,
então é capital LAND, eu defini a variável go path,
que vai ser o diretório onde você vai manter os modulos de go,
o padrão é o dollar home, seu diretório pessoal barra-go, como eu já defini aqui explicitamente,
para poder rodar qualquer comando, o programa que for instalado como o modulo de go,
sem ter que dizer o caminho todo, você tem que adicionar a pasta de binários bin,
que está dentro da pasta do go path, nesse caso pasta pessoal barra-go, barra-bin,
ao meu path, tem que adicionar o path para ele poder encontrar,
então eu criei a variável intermediária go-bin, que na verdade é go path barra-bin,
que é dollar home barra-go barra-bin, e isso vai adicionar o meu path no final aqui e adicionar,
e com isso eu posso salvar esse arquivo, sair, ou você abre o novo terminal,
ou você dá o source do seu arquivo RC,
no meu caso eu posso falar, um source dollar barra-bash-rc,
será que funcionou, ou não, vamos ver, eu posso estar com qualquer arquivo aqui,
só para testar, por exemplo, vamos ver aqui,
qualquer, se você souber qualquer pacote de go, você pode instalar e ver,
funcionou mesmo, e vou instalar esse pacote chamado ray só para testar,
deixa eu só ir para uma pasta aqui,
para uma pasta qualquer, não tem nada nessa pasta,
então estou no diretor que não tem nada, não tem go.mod,
vamos fazer o seguinte, a gente vai instalar, vou falar go install,
github.com barra-kill-ray-athletics,
então falei go, se você passa a instalar,
se você passa github.com barra-rk-ylr-ray-ah-ah-ath,
leitest, para dizer que é a versão mais nova,
isso ele vai baixar o modo e se eu dar o ls aqui,
na minha parte da esquerda eu vou dar o ls, na verdade eu quero evitar o cd,
pasta pessoal barra-go, para te mostrar o ls aqui,
traço l, tem duas pastas bim e pkg,
se eu dar o ls do bim, que é o gobin,
tem o arquivo ray que eu posso agora chamar ray,
de qualquer lugar, sem precisar dizer o caminho todo,
que está para o pessoal, barra-go, barra-bin, barra-ray,
então vou falar ray, https, dois pontos,
barra-go-long, por exemplo, e ele roda o comando,
certinho, porque está no path, o gobin,
e se você quiser olhar na pasta gopath,
barra-pkg, tem barra-mode,
tem os arquivos dos modus que foram baixados,
por exemplo, barra-github.com, barra-rk-ylr-ray,
a versão 014, tem aqui os arquivos do código fonte
desse módulo ray que eu baixei, está certo?
Então aprendemos como instalar a versão mais atual do go-long
em um sistema de Ubuntu Linux, bem simples,
meu sistema já tinha uma versão que era mais antiga,
a gente banteou essa versão, mas só fez mudar,
renomear o link que tinha na pasta barra-usr-bin,
para go traço o número da versão anterior,
aí eu instalei a nova versão do go em barra-usr-loco, barra-go,
e a gente pega e adiciona ao nosso path, barra-usr,
barra-loco, barra-go, barra-bin,
para o nosso shell poder encontrar o comando go da última versão,
toda vez que a gente falar as letras g-o, go.
E no final nós definimos o gopath, gobin,
e adicionamos o gobin a nosso path para que módulos de go-long
que forem instalados também possam ser acessíveis de maneira
conveniente sem ter que digitar o caminho completo,
de tilda, barra-go, barra-bin, está certo?
Por essa aula é só.
Se você gostou, por favor, dê o seu like,
não se esqueça de se inscrever e até a próxima.


0020-01 Como Instalar a Versão Mais Atual do Go Golang no Ubuntu Linux com o Arquivo Tar Gz

Estilo Padrão de Código de Go: Formatação Automática em Golang com o go fmt

```markdown
# Resumo da Apresentação sobre Formatação de Código em Golang

## Introdução
O apresentador discute a formatação de código na linguagem Golang, focando no comando `gol fmt`. A linguagem foi projetada para ser simples, com uma formatação de código padrão que deve ser seguida por todos os desenvolvedores, reduzindo a necessidade de decisões sobre estilo pessoal.

## Princípios de Golang
- **Simplicidade**: A linguagem foi criada para evitar complexidade.
- **Uniformidade**: Existe uma única maneira de escrever o código, o que pode ser bom para alguns, mas problemático para quem prefere personalização.

## Regras de Formatação
- **Indentação**: 
  - Apenas tabulações (caractere `tab`) devem ser usadas para a indentação, eliminando conflitos sobre o uso de espaços.
  - A configuração do editor pode ajustar o comprimento visual das tabulações (e.g., aparecer como 2, 4 ou 8 espaços).

## Demonstração do comando `gol fmt`
1. O apresentador mostra um código mal formatado, com problemas de alinhamento e uso excessivo de espaços.
2. Após rodar o comando `gol fmt`, o código é automaticamente formatado de acordo com o padrão da linguagem.
3. O comando corrige questões como:
   - Chaves devem estar na mesma linha que o comando (sem quebra de linha).
   - Espaços extras são removidos e substituídos por tabulações.

## Benefícios do `gol fmt`
- **Consistência**: Garante que todo o código esteja de acordo com as normas da linguagem antes de fazer commits.
- **Elimina reclamações**: Facilita a vida dos desenvolvedores ao evitar que o código quede exposto a críticas por formatação.

## Conclusão
Em Golang, a formatação do código é padronizada e os desenvolvedores devem aceitar essas regras para manter a uniformidade. O uso do `gol fmt` é recomendado para todos que desejam evitar problemas de formatação antes de compartilhar ou fazer commits de seu código.

## Encerramento
O apresentador agradece o público, incentivando a curtidas e inscrições no canal.
```


Olá pessoal, na estalava falar de formatação de código na ligação de Golang.
Então Golang, vou falar do comando gol fmt.
Antes disso, falar um pouco, comentar sobre a linguagem Golang, em termos de formatação do estilo do código.
Então, o cara que fiz o Golang, queria como princípio fazer a linguagem bem simples e sem ter que pensar muito de como escrever o código.
E por isso que eles decidiram que vão abrir mão de ter flexibilidade para fazer todo mundo escrever o código de uma maneira só.
Então, no Golang, a maneira de escrever o código não é flexível.
Então, só vai ter uma maneira de fazer a coisa que você quiser.
Então, por causa disso, o Golang define uma formatação padrão de estilo que todo mundo tem que seguir.
Então, por um lado, é bom que facilita a pessoa não ter que perder tempo de fazer assim ou fazer do outro estilo, não sei o que.
Mas, por outro, tem gente que não gosta, tem gente que acompanha esse que tem seu próprio estilo e gostaria de personalizar isso.
Então, é uma faca de duas lá, duas láminas.
Então, uma coisa para você se lembrar, que por exemplo, a indentação no Golang, eles decidiram que vai ser indentação usando o caractere de tabulação, o tab.
Então, teve esse conflito, né?
Ou você usa para indentação espaço em branco, por exemplo, dois espaços no mínimo, quatro espaços, oito.
Ou você usa o caractere tab, que é o contra-barra T.
Então, os designers do Gol decidiram que vão usar tab, então todo mundo tem que usar tab no código de Gol.
Então, você tem que saber disso.
Então, quando você usa tab, você pode configurar só editor para que a tab apareça de um certo comprimento.
Por exemplo, apareça como dois, como se fosse dois espaços, como se fosse quatro, como se fosse oito, por exemplo.
Certo?
Então, para demonstrar que o comanda Gol FMT, eu estou no meu editor de texto, que é o Atom.
Eu habilei a opção de mostrar invisíveis.
Isto é, por exemplo, os espaços, a tab e outros caracteres, em vez de aparecer em branco, vai aparecer um caractere para indicar que aquele caractere é um tab, tá?
É um espaço em branco, sim por diante.
Você vê que as tabulações invisíveis para o tab vai ser nesse caractere de dois sinais de maior combinado juntos, né?
Desse de chevron, duplo chevron.
Então, com isso, habilitado o meu editor, eu vou para o meu arquivo que eu criei, esse arquivo aqui que eu fiz várias formatação bem ruim, né?
Vamos te dizer.
Mas eu fiz de propósito, várias indentação, não estar no mesmo nível, por exemplo.
Esse fecha, aqui, chave da funk de fora, não está alinhado a palavra funk com o fechamento da chave, não está alinhado no else, nem do if.
E eu adicionei espaço aqui, muito espaço, depois da vígula, antes do segundo parâmetro da função de fora.
E essa função, eu botei o primeiro letra capitalizada para poder disponibilizar fora.
Quem chama esse pacote de fora tem acesso a essa função, mas ele...
Por exemplo, se você usar o gol lint, depois que a gente vai ver, ele vai reclamar, você tem que botar comentário, não sei o que, e tal e tal.
Mas a gente vai falar só de formatação agora, com o gol FMT.
Então, o gol FMT vai, quando você chama esse comando, ele vai formatar o seu código da maneira padrão do gol.
Eles querem que você faça o seu código e tal e tal, mas antes de você fazer o comete, por exemplo, no get, para você terminar de escrever o seu código,
você vai fazer o comete, roda o gol FMT antes de tudo para poder formatar tudo no padrão do gol, para não ter nenhuma reclamação.
Ah, você não usou esse tipo de padrão, não sei o que, não sei o que.
Então, ele vai mudar o código e vamos ver o que acontece.
Falar gol, espaço FMT, espaço nome do arquivo não, underscore, formatado.go.
Ah, eu esqueci de fazer uma coisa, desculpa.
Certo? Então, vamos ver o que...
Não formatado, linha 7.
Em verdade, o contato foi encontrado, então, é ok.
Agora, cláusula, linha 7.
O contato foi encontrado.
Aqui.
Ah...
Clicando aqui...
Acho que foi na...
Talvez seja na mesma linha que o fecha.
Vamos ver.
Deixa eu deixar assim.
Pronto.
Linha 6.
Tem uma coisa.
Então, está reclamando...
O else tem que estar na mesma linha do fecha-chave.
E o abrir-chave do else-if tem que estar na mesma linha do else-if.
Agora está reclamando na linha 14.
Mesma coisa, tem que estar na mesma...
A sintaxe do gol é sempre assim, não há flexibilidade das chaves, né?
Então, eles tinham decidido que para a linguagem gol todo mundo vai ter que usar a chave...
Abre a chave na mesma linha do seu statement, né?
Nesses casos, funk main, funk de forums, ok, bull, f no seu que...
Sempre na mesma linha, não é?
Eu posso fazer na linha nova.
Então, não vai ter esse...
Ah, como é que se fala?
Essa briga, não.
Meu estilo é na mesma linha dos statement.
Não, meu estilo é sempre quebrar a nova linha para abrir a chave.
Então, o gol decidir que vai ser na mesma linha assim que eles querem.
Pronto, então, olha o que aconteceu.
Eu rodei o gol FMT depois de consertar que é o exerro de sintaxe.
Na verdade, o exerro que eu tive antes era o de sintaxe.
Não é assim que o gol FMT não rodou ainda para formatar o código, né?
Então, eu tinha que consertar aqueles erros da sintaxe do gol que tem que ter a chave na mesma linha.
Então, ótimo que o código todo foi formatado direitinho na maneira do gol, que é padrão.
Note que esses chevros apareceram aqui nos espaços de indentação.
Esse, na verdade, representa a tabulação, a tab, caractere tab.
E, no meu caso, aparece como dois espaços, mas, na verdade, pode ser quanto espaço você quiser, dependendo da configuração do editor.
Você pode configurar o seu editor para que a tab apareça como dois espaços, como eu já fiz.
Quando eu tenho aqui, ou que aparece como quatro espaços, ou que aparece como o oito, assim, por diante, você pode escolher.
Então, só te mostrar aqui o controle de antes e o depois.
Olha só, antes, tudo desalinhado, passo extra e tal e tal.
E depois ele consertou os espaços extras e alinhou tudo e converteu, na verdade, converteu.
Você note que antes eu tinha espaço na indentação, que é esse ponto, ponto, ponto.
Espaço em branco em vez de tab, só tinha tab na linha 7.
Aí ele mudou, modificou e substituiu todos os espaços por tab, que é a maneira do gol que eles querem que você faça.
Então, com isso, você pode ver aqui no meu getd, porque eu fiz, ele consertou tudo.
E você pode fazer o seu comete depois de rodar o gol FMT, que ele já vai estar formatado na maneira que eles querem e não vai ter reclamação.
Está certo?
Então, esse é o gol FMT para poder formatar o seu código de gol na maneira padrão.
Normalmente, você pode escrever seu código e, quando você terminar de escrever, roda gol FMT para ele poder já formatar tudo certinho.
Aí você pode já fazer o get comete e criar o seu comete com tudo já formatado.
Sem problemas, ninguém vai reclamar a galera do gol, não vai reclamar do seu código de gol.
Então, o gol, o reiterão no gol, ele... uma linguagem bem assim...
Só há uma maneira de fazer isso, e essa é a maneira, e todo mundo tem que fazer dessa maneira, no alto-accivilidade da linguagem.
Então, é uma linguagem simples, nesse termo, você só tem uma maneira de fazer a coisa.
E, quando a gente fala de estilo de programação, os criadores de linguagem de gol, aqueles desenvolvedores da linguagem,
decidiram que o estilo só vai ser um e vai ser o estilo padrão de gol, e ninguém vai poder mudar isso.
Então, por exemplo, quando abre a chave, vai ser na mesma linha, não pode... não é da nova linha.
Em termos de espaço de intentação, você vai sempre usar o contra-barra take, o caractere de tab.
Não é espaço em si próprio.
E assim por diante, né?
Tá bom?
Então, por essa aula é só.
Espero que você tenha gostado, não se esqueça de deixar o seu like,
e se inscreva no canal e ajuda muito.
E até mais!


0020-02 Estilo Padrão de Código de Go: Formatação Automática em Golang com o go fmt

Formatação de Código em Golang: Uso de goimports para Torná-lo Estilo Padrão do Go

```markdown
# Aula sobre Go Imports

Olá pessoal, estamos de volta com mais uma aula!

## Introdução ao Go Imports

Nesta aula, falaremos sobre o comando **Go Imports**, que é utilizado para formatar o código de acordo com o estilo do **Go FMT**. Primeiro, faremos uma demonstração do **Go FMT** e, em seguida, utilizaremos o **Go Imports** para comparar as diferenças.

### Demonstração do Go FMT

- Foi criado um arquivo chamado **bagunça.go** que contém funções exportadas (iniciadas com letra maiúscula) e importações.
- As importações não estão ordenadas alfabeticamente e existem problemas intencionais de indentação.
- Algumas importações estão faltando, como `md5` que foi chamado, mas não importado, e `strings`, que está presente mas não é utilizado.

Para formatar o arquivo, utilizamos o comando:
```
go fmt bagunça.go
```
Isso formatou os espaços, trocou espaços por tabulações (padrão do Go) e ordenou as importações, mas não corrigiu as importações que estavam faltando ou as que não estavam sendo utilizadas.

### Utilização do Go Imports

Para usar o **Go Imports**, precisamos instalá-lo:
```bash
go install golang.org/x/tools/cmd/goimports@latest
```
Como o diretório não define um módulo (sem `go.mod`), fazemos dessa forma. Depois, podemos usar o comando:
```
goimports -l -w .
```
- `-l` lista arquivos com formatação errada.
- `-w` modifica o arquivo permanentemente.

### Resultados após uso do Go Imports

- O **Go Imports** corrigiu a indentação e consolidou as importações em uma única lista, ordenando-as alfabeticamente.
- Ele também removeu importações não utilizadas (como `strings`) e adicionou as importações necessárias que estavam faltando (como `html`). 

### Conclusão

O **Go Imports** é uma ferramenta mais poderosa do que o **Go FMT**, pois além de formatar, também organiza e corrige as importações.

Se você gostou do vídeo, deixe seu like, comentem e se inscrevam no canal para mais conteúdo! Até mais!
```

Olá pessoal, estamos de volta com mais uma aula.
Nessa aula eu vou falar do comando Go Imports, que é utilizado para poder também formatar
o código na maneira do Go FMT.
Primeiro eu vou demonstrar do Go FMT e depois eu vou usar o Go Imports para a gente comparar
com a diferença entre eles.
Então aqui na janela do lado direito eu tenho um código fonte, eu creio o arquivo bagunça.go
e tem duas funções aqui que são exportadas porque é a primeira letra, é a letra maiúscula.
Tem os importos aqui também, a note que os importos não estão ordenados de maneira
alfabética e eu tenho vários, vamos dizer, problemas de indentação que eu fiz de propósito
só para o formatador, o comando fazer trabalho dele para ver se funciona corretamente.
Note que eu tenho as coisas como por exemplo, eu tenho a chamada do md5.new mas eu não importo
ele, então esqueci de importar, vamos ver o que ele faz nesse sentido.
E outro caso também é o strings, eu acho que eu não uso aqui, se eu procurar não
é usado.
Então vamos lá, se eu falar Go, espaço FMT, espaço, o nome do arquivo bagunça.go,
note que ele já formatou os espaços, converteu o espaço para tab porque no Go ele usa sempre
tab para indentação, esse é o padrão do Go e as indentações estão certinho, os
notos vamos ver, comparar aqui, importe ele bem que ordenou alfabeticamente nesse bloco
da linha 5 e 6 mas ele não notou que strings só formatou, não fez nenhuma modificação
se você esqueceu de importar uma coisa, por exemplo md5 ou se eu importei algo que não
uso.
Então basicamente espaço, indentação e algum ordem ali.
Agora nós vamos fazer com Go Imports, para poder usar o Go Imports a gente vai ter que
baixar esse programa, eu vou reverter o arquivo no lado direito, vou voltar o meu terminal
aqui, vou falar Go, espaço install, espaço golang.org, barra x, barra tools, barra cmd,
barra Go Imports e a rouba a versão que eu vou usar a última versão, mais nova, playtest,
como eu não estou dentro de um módulo de Go, o meu diretório não define o módulo com
arquivo Go.mod, eu tenho que fazer dessa maneira aqui, estou usando a versão do Go 1.16, certo?
Com isso ele vai baixar, eu já tinha baixado antes por isso que não apareceu aqui as linhas
do repositório e tal e tal, ele vai lá nesse repositório e vai baixar a última versão,
eu vou dar um ls no meu GoBin, eu já tenho um comando aqui Go Imports, eu posso chamar
Go Imports, espaço traço l, espaço traço w, espaço ponto, então opção, vamos escanear
no diretório presente que é o ponto, opção traço w para poder dizer para o Go Imports
modificar o arquivo, permanentemente, opção traço l para poder listar os arquivos com
formatação errada.
Noite do lado direito da tela, meu editor de texto que já mudou várias coisas, vamos ver aqui.
Então os espaços foram concertados na indivisão também com tab, note que esse
carácter invisível significa tabulação no meu editor de texto.
Uma coisa que eu tinha disto do MD5, desculpa, eu quis dizer o HTML, não é um MD5, HTML
que eu tinha esquecido de importar, tá certo?
O MD5 já estava aqui no crypto, barro, MD5, eu quis dizer o HTML que eu esqueci de importar.
Então vamos ver, ele consolidou os dois imports em uma lista só e ordenou alfabeticamente,
deu strings porque eu não uso em nenhum lugar, adicionou HTML porque eu uso na linha
16 aqui e basicamente isso, ele faz algo a mais que o Go FMT, no caso do Go FMT ele não
tinha consolidado a lista de imports e não tinha importado aquilo que a gente esqueceu.
Também acho que não tinha removido aquilo que a gente não usa, o Go FMT novamente,
bagunça, aquilo que a gente não usa que é o strings ainda ficou, aquilo que a gente
usa que HTML mas esqueceu de importar não foi incluído, e a lista não foi consolidada
em um só, em um só import.
Tá, então esse é o uso do comando Go Import que você pode baixar com Go install, golang.org,
com x, barra tools, barra cmd, barra go imports, é a rouba latest.
Podemos usar Go Import com as opções traço l, traço w e você pode especificar o arquivo
ou se escanear o diretório presente e todos os subdireitórios com o ponto final.
Então é isso, espero que tenham gostado do vídeo, por favor deixe o seu like, e qualquer
comentário e se inscreva no canal para a gente poder continuar aí, ajuda muito.
Até mais então.


0020-03 Formatação de Código em Golang: Uso de goimports para Torná-lo Estilo Padrão do Go

Análise de Código de Golang com Linters: go vet, golint, golangci-lint

# Resumo da Apresentação sobre Ferramentas em Go

## Introdução
- O apresentador discute duas ferramentas na linguagem Go: **GoVet** e **GoLint**.
- Também apresenta o **GoLangCI**, que é uma ferramenta que executa múltiplos linters simultaneamente.

## GoVet
- **GoVet** é uma ferramenta que verifica o código em busca de problemas comuns:
  - Identifica variáveis não utilizadas.
  - Verifica se todos os argumentos de funções foram fornecidos.
- Exemplos práticos com o arquivo `Mostra.go`:
  - Problemas encontrados como falta de importação (`fmt`) e variáveis não utilizadas.
  - Sugestões para corrigir chamadas de função, como garantir que o número correto de argumentos seja passado.

## GoLint
- **GoLint** não faz parte do Go padrão, mas fornece sugestões de melhoria para o código.
- Sugestões incluem:
  - Adição de comentários para funções exportadas.
  - Eliminação de `else` desnecessários.
- GoLint ajuda a documentar e melhorar a legibilidade do código.

## GoLangCI
- **GoLangCI** é uma ferramenta que roda vários linters de uma vez, facilitando a análise do código.
- O processo de instalação é semelhante ao GoLint.
- Roda não apenas GoVet e GoLint, mas também outros linters que podem fornecer sugestões adicionais.

## Conclusão
- O apresentador revisa as principais ferramentas:
  - GoVet para encontrar erros de sintaxe e problemas lógicos.
  - GoLint para sugestões de melhoria.
  - GoLangCI para uma execução mais simplificada de múltiplos linters.
- Finaliza convidando os espectadores a se inscreverem no canal e deixarem feedback.

---

**Nota**: A apresentação é voltada para desenvolvedores que buscam melhorar a qualidade do código escrito em Go e que desejam adotar boas práticas com o uso dessas ferramentas.

Olá pessoal, na sala do falar de mais uns ferramentas aqui da linguagem Go.
Eu vou falar de GoVet e GoLint, falar de LinkedIn.
Então, LinkedIn é quando tem um programa que olha o seu código e vê se não tem algum problema.
Então, por exemplo, a gente vai usar o GoVet para ver se tem nenhum problema com variáveis que não são usadas,
ou você esqueceu de passar todos os argumentos para a função e tal e tal.
Também vou falar do GoLint para poder receber sugestões para melhorar o código.
Não necessariamente precisa fazer para o código rodar, mas seria melhoria.
Vamos terminar com um programa bem legal chamado GoLangCI, traço LinkedIn que roda todos esses LinkedIn ao mesmo tempo.
Vários LinkedIn.
Então, vamos começar aqui. Eu tenho esse código, a Mostra.go, nessa parte do LinkedIn, traço o Go que eu fiz.
Tem duas funções aqui. Eu só fiz o código aleatório para demonstrar como usar esses comandos.
Não é código que tem significado, né?
É só para demonstrar mesmo os erros para consertar no GoVet e as sugestões que o GoLint vai nos dar.
Primeiro, vamos ver GoVet, né?
Vou falar Go, espaço, v, e, te.
Passa o nome do arquivo, a Mostra.go.
E já de cara, ele me diz que teve problema dos argumentos aqui.
VET, a Mostra.go, coluna 2.
Eu estou usando FMT, está dizendo que o nome não foi declarado, undeclared name.
Isso significa que a gente esqueceu de importar, então vou lá em cima e vou dizer import.
Abre aspas duplas FMT.
Vou rodar o GoVet, a Mostra.go de novo. Agora tem outro problema.
A Mostra.go, linha 15, coluna 6, n123n, que é o nome da variável, foi declarado, mas não foi usado.
Então essa variável que eu fiz, n123n, e eu atribui um valor, mas eu nunca usei essa variável.
Esse é mais um problema. Você pode, neste caso, remover a variável.
Como não está usado.
Da GoVet de novo, agora está falando na linha 16, coluna 2, printf, que eu coloquei 2 placeholders,
percentual D por cento D, duas vezes, então a gente espera que a gente ponha, depois da vígula, 2 argumentos.
Está dizendo que corretamente que printf por cento D, leia argumento número 2, mas a chamada só teve um argumento.
Eu esqueci do segundo percentual D, que é poder botar qualquer coisa, sei lá, ou uma variável, ou um número, só para consertar isso.
Então GoVet a Mostra.go agora não tem mais problema.
Então esse é o GoVet para encontrar esses erros antes de você já compilar o código.
Então GoVet pode usar aí para ver se você não esqueceu certo número de argumentos,
se você não tem variáveis que não são usadas e assim por diante, você esqueceu do import e tal e tal.
Agora eu vou falar do GoLint, que é um pacote de terceiro, na verdade não, não faz parte do rumo do Go.
Esse GoLint vai nos dar sugestões para poder melhorar o código.
Depende de você se você quiser seguir ou não.
Muitas das sugestões valem a pena para corrigir o código e melhorar, outras você colhe, né, se realmente vale a pena ou não, se você concorda ou não.
São apenas sugestões, você não é obrigado.
Não vai dar problema na hora de concupilar.
Então vamos lá, vamos baixar isso.
Então o nome é GoLint e está no repositório lá no site do golang.org para poder eu instalar como se fosse globalmente, né,
para ele baixar e colocar o binário, arquivo binário na parte do GoPath-bin, que é o GoVin.
Você diz Go, install, golang.org, que é o caminho para esse módulo, para sush, barra x, barra lint, barra golint,
arroba, leite isso. Agora eu vou te mostrar esse comando se você não sabe.
Vou instalar para poder baixar e instalar o módulo, o caminho do módulo golang.org, barra x, barra lint, barra golint, aí arroba e a versão.
Latest significa a versão mais atual. Note que sdiretória aqui não tem arquivo Go.mode, então não tem.
Eu estou usando o Go na versão aqui 1.16, deixa eu mostrar aqui a nova tab, golversion.
Estala para você ver 1.16 para 5, tá? Que versões atteriores esse comportamento é diferente, então fica mudando as coisas,
então só para te dizer, versão 1.16 para 5 é assim que baixa o módulo e instala para poder ter o binário.
Ele vai baixar e se eu olhar agora ls, pasta pessoal, barra, na verdade o golpath, dola golpath, que eu já tenho, que é pasta pessoal, barra gol,
no meu caso, barra bin, que na verdade é o dola golbin que eu citei, eu tenho lá o golint que é o comando que eu quero rodar.
Então eu posso falar golint, amostra.go e ele vai mostrar sugestões, por exemplo, linha 6, a primeira, vamos ver a primeira, linha 6.
A função de fora que está exportada, porque eu usei a primeira letra da função é maiúscula,
significa que essa função é acessível de fora, outros módulos de fora podem ter acesso a essa função.
Deve ter comentário ou você não deve exportar, então ou você coloca o dminusco e não exporta, não disponibiliza essa função para outros de fora poder enxamar,
ou você adiciona esse comentário para poder aceitar essa sugestão de lint.
Comentário seria o que? Você adicionar um comentário para poder documentar essa função para aquelas pessoas que vão usar a função,
os invocadores da função que são de fora, para saber qual é a API, o que essa função faz.
Então se eu botar qualquer coisa no comentário, o que acontece?
Ele conserta o erro, mas ele diz outro, na linha 6 agora está dizendo, coluna 1.
Comentário na função exportada de fora tem que ser da forma de fora 3 pontos, elipse.
Então isso significa o que? Todo comentário, se você quiser fazer o comentário para documentar essa função em Go,
você tem que começar o comentário com o nome da função, exatamente igual o nome da função aqui.
Então tem que ser de fora e espaço e qualquer coisa que você quiser, ele vai consertar isso, certo?
Consertou aquele erro, então tem que ser mesmo nome da função copiada aqui no comentário, espaço e qualquer coisa que você quiser.
Isso é a sugestão para poder adicionar a documentação.
Agora vamos partir para o próximo, para a sugestão de lint.
Eu mostrei a Go, linha 10, if block, blockgif termina com return statement,
drop this else inoutend.
Então está dizendo que if esse blockgif termina com return,
drop this else inoutend.
Eu acho que a gente tira os else e o outro dentro é...
Tira a indatação para fora.
Vamos ver.
Se você tem um if com else,
essa pode tirar o else que é a mesma coisa, if,
com o return true aqui e o return false, seria a mesma coisa com else.
Então o else é opcional, então ele sujeira que você não conhece.
Essas foram as sugestões do lint, do golint.
Olha o que acontece se eu botasse espaço,
quebra de linha depois desse comentário da função de fora.
Agora ele reclama e mostra a sugestão que a função exportada de fora
tem que ter comentário ou não deve ser exportada.
A mesma coisa de antes, isso significa que quando você quebra a linha
ele não associa mais esse comentário, essa função,
então ele não sabe que tem comentário.
É bem particular as coisas.
Agora vou terminar esse vídeo com a demonstração do golangci traçolint.
Vou mostrar o site.
Esse aqui é o pacote.
github.com.golangci,
golangci traçolint.
Você vê aqui a descrição, fastlinters, runners for go.
Ele roda os linters, maneira rápida, a linguagem gol.
Então esse cara aqui vai rodar golvat,
vai rodar golint e vários outros que ele tem.
Para poder instalar, vamos ver aqui na minha máquina, o MyMachine.
Ele mostra vários comandos, mas o que importa,
você pode instalar através do Go install.
É só pegar o caminho aqui dele aqui, para você ver aqui.
Deixa eu te mostrar.
No terminal, deixa eu colocar.
Terminamos no gênero à esquerda, vou dizer o seguinte,
vou falar gol install e o caminho desse pacote,
deixa eu copiar aqui,
github.com.golangci,
golangci traçolint.com.golangci,
traçolint.com.golangci,
github e a versão, eu posso botar leiras para ser a última versão,
em vez de especificar o número.
Na hora de que eu não tenho nenhum arquivo go mod,
na diretora pessoal,
e eu estou usando a versão 1.16 do golangci.
Então esse comportamento vai funcionar aqui.
E é diferente as versões anteriores do gol install.
De detalhes, então cuidados se você estiver usando a versão diferente,
a do gol aí, pois isso aqui se não funciona,
da maneira desigada.
Se ele vai baixar, ele demora um pouquinho.
Então golangci é algo para facilitar a gente rodar vários comandos ao mesmo tempo.
Em vez de eu rodar golvert, golint e vários outros separadamente,
você pode rodar golangci-lint e ele vai rodar tudo de uma vez para você,
em vez de você ter que digitar cada comando separadamente.
Então ele baixou lá, se você dá uma olhada no LS,
no seu golpath-barrabin, no meu caso tem um golbin,
apareceu lá o comando executável do golangci-lint,
você pode dizer golangci-lint-run,
aí eu vou botar o nome do arquivo,
não esquece, a mostra é o Portugal.
Volta no código-fonte, você note que ele já...
ele rodou vários linters, não sei nem qual é,
especificamente quais, mas tem uns linters aí que ele mostrou um sugestão
dizendo que a função de fora não é usada.
Ele mostrou outra na linha 8, que eu devo usar b igual a 2,
em vez de esse fb igual a 2, return true, return false,
o que faz sentido, né?
Se b foi igual a 2, já é verdadeiro esse próprio,
só precisa retornar isso, em vez de fazer fb igual a 2,
retornar true, retornar false, fora.
Faz sentido essa segunda, eu não sei se a primeira faz sentido
essa sugestão aqui, é claro que eu fiz um pacote mesmo,
fiz esse outro pacote separado e quisesse mesmo que o pessoal
usasse essa função, talvez, eu não sei, se eu tirar a main e colocar
package outro, que será que acontece se eu rodar o linter.
Agora está dizendo que eu não estou usando o fmt, faz sentido.
Agora está dizendo só para fazer aquele return b igual a 2,
tem esse negócio de return true e return false, fora, faz sentido.
Pronto, então não reclamou do de fora, né?
Agora eu acho que faz sentido agora, porque eu tinha main,
ele pensou que era um arquivo, um módulo que tinha a função main
e ia rodar para o seu próprio comum comando,
em vez de uma espécie de biblioteca de terceiro ou api.
Agora faz sentido, se não tiver main, significa que alguém
vai importar esse módulo meu chamado que tem o pacote outro
e vai usar a função de fora, por isso que o erro lá de fora
não é utilizado, não deu mais, então faz sentido.
Então vamos recapitular tudo.
Aprendemos o dao gol vetch para poder rodar e encontrar erros,
por exemplo, você esquecer de passar o número corret de parâmetros
ou você tem uma variável que você não usou.
Aprende também o comando de terceiro,
dado hospedado no golang.org, do gol lint para poder
receber sugestões para poder melhorar o colho.
No nosso caso, a gente recebeu sugestão para comentar,
fazer o comentário de Godoc da nossa função que foi exportada.
Finalmente aprendemos a baixar esse outro programa de terceiro,
golang cei traçulinte, que ele roda vários lintes de uma vez.
Você note que ele pegou várias coisas que não tinha pegado antes
no gol vetch e no gol lint, é porque ele roda outras coisas também
em outros lintes.
Lintes é esse programinha que analisa o seu código da sua sugestão,
das sugestões, você deve fazer isso porque isso e tal.
Então a gente baixou, aprendeu a usar o gol install na versão 1.16.
Outras versões, abaixo, está outro comportamento.
Então gol install, caminho, arroba e o número da versão
ou latest, que se for a versão mais atual.
Isso no caso, se eu não tiver o arquivo gol.mode
no diretor presente, se tivesse, acho que não precisaria você
colocar a versão at, alguma coisa.
Então é só rodar o golang cei traçulinte,
espaço run, espaço nome do arquivo.
A gente vai olhar lá no pasta dos binários do gol,
que estão como no gol lint, o golang cei traçulinte está lá
e nós podemos rodar.
Então por essa aula é só, espero que tenham gostado,
não se esqueçam de deixar o seu like, por favor,
se inscrevam no canal, reajuda muito e até a próxima.


0020-04 Análise de Código de Golang com Linters: go vet, golint, golangci-lint

Ambiente de Desenvolvimento IDE de Golang no Visual Studio Code com Extensao para Go

# Resumo da Aula: Uso do Visual Studio Code para Desenvolvimento em Golang

Na aula, foi demonstrado como utilizar o **Visual Studio Code** (VS Code) como um ambiente de desenvolvimento para a linguagem **Golang**. A seguir estão os principais tópicos abordados:

## 1. Criação de Arquivo e Seleção de Linguagem
- O professor cria um novo arquivo no VS Code e seleciona a linguagem "Golang".
- Ao escolher a linguagem, o VS Code sugere a instalação de extensões recomendadas.

## 2. Instalação de Extensões
- O aluno instala a extensão "Go" para VS Code (versão 0.26.0).
- A extensão requer a instalação de várias ferramentas, como o servidor de linguagem **Go Language Server (golpls)**.
- Um terminal é aberto para mostrar o progresso da instalação.

## 3. Escrita de Código
- O aluno escreve um exemplo básico em Golang, incluindo o pacote `fmt`.
- O VS Code sugere métodos disponíveis através do módulo `fmt` ao digitar.

## 4. Funções Úteis
- **Navegação**: Permite ir diretamente para a definição de uma função usando o atalho **F12**.
- **Documentação**: Ao passar o mouse sobre uma função, a documentação é exibida.

## 5. Formatação e Corrigindo Erros
- A extensão formata automaticamente o código ao salvá-lo.
- Remove imports não utilizados e adiciona automaticamente os necessários ao salvar.
- O sistema alerta sobre erros, mostrando mensagens e permitindo correções antes da compilação.

## 6. Depuração com DLV
- Demonstração de como iniciar a depuração de programas usando o **Delve (DLV)**.
- Ao tentar iniciar a depuração, a instalação do DLV é sugerida.

## Conclusão
A aula proporcionou uma visão abrangente sobre como configurar o VS Code para desenvolvimento em Golang, destacando funcionalidades como sugestão de código, documentação, formatação automática, importação de módulos e depuração. 

**Próximos passos**: Continuar explorando a configuração de depuração e outros recursos do VS Code na próxima aula. 

---

Essa é uma breve recapitulação dos tópicos discutidos na aula, útil para revisão ou para aqueles que se interessam por desenvolvimento em Golang utilizando o VS Code.

Nesta aula vou demonstrar o uso do Visual Studio Code vs Code como um ambiente de desenvolvimento
para a linguagem Golang, Go.
Estou aqui com o Visual Studio Code aberto no lado esquerdo da minha tela e vou criar
um novo arquivo.
Está dizendo aqui para eu só assinar um idioma, vou clicar e escolher Gol.
No momento que eu escolho o idioma ele já mostra que deseja instalar as distenções
recomendadas para Gol.
Então eu vou instalar, só clicar instalar, isso na verdade abre o menu de distenções,
vou Shift X e instala a extensão Gol for vs code, no meu caso versão 0.26.0.
Agora quando ele instala essa extensão para Gol ele vai dizer aqui no canto do lado direito
abaixo da tela que o comando Gol pls não está disponível.
Então quando a extensão aqui é instalada ela requer vários programas de Gol para poder
funcionar, uma delas é o Gol pls que é um servidor de linguagem de Gol.
Então você pode clicar em install e instalar somente esse aqui, mas você vai ver que ele
também vai instalar outras ferramentas, então não é uma só.
Aqui uma tela do terminal abriu, um painel do terminal dizendo que está instalando Gol
pls no meu canto de binários do Gol que é a minha parte da pessoal barra Gol barra
bin.
Todas as ferramentas foram instaladas, não sei o que, não sei o que.
Bem, não ainda não foi, você vai ver já que ainda não instalou tudo.
Vamos voltar ao meu arquivo aqui e vou começar a escrever um código em Gol.
Vou falar package, espaço main, vou falar funk main, abre fecha parênteses, abre fecha
ptl chaves, vou salvar arquivo, vou chamar de main.go, deixa eu ver se...
Então apareceu aqui talvez porque eu já tenha instalado, mas normalmente se você instalar
a extensão do zero e ele vai pedir também para instalar outras ferramentas.
Então se você receber essa mensagem, você pode clicar em install para instalar uma por
uma ou você poderia clicar em install all, instalar todas, para não ter que clicar uma
por uma.
Então eu provavelmente já tinha instalado certas ferramentas, por isso que não perguntou.
Então vamos continuar.
Então eu fiz aqui a referência ao módulo fmt e você note quando eu apertei ponto, ele
já mostra uma sugestão de vários métodos e estão disponíveis através do módulo
fmt.
Então por exemplo println, aqui que é isso que eu posso escolher, eu clico ou eu posso
usar o teclado, as certas para baixo e para cima e apertar enter para selecionar.
Vou abrir parênteses para definir os argumentos, você note que ele abre um painelzinho com
a lista de parâmetros que o println leva.
Tem também abaixo disso dessa assinatura da função, uma documentação dizendo o que
a função faz.
Aqui nesse caso está dizendo que o println formata usando os formatos padrões para operando
e escreve para o standard output, saída padrão.
E assim por diante.
Então eu posso dizer alguma coisa.
Certo?
Se você também usar o ponteiro do mouse e deixá-lo sobre a função, qualquer função,
ele também mostra esse painelzinho com a assinatura da função e a documentação.
Tem também um link para você clicar e ver o módulo no pkg.go.dev.
Outra função que eu também acho muito útil é você ir para a definição do método ou
função.
Você pode clicar com o botão direito na função e clicar ir para a definição.
O atalho é f12.
Você note que ele já abre o arquivo onde essa função é escrita.
Nesse caso está no código fonte da linguagem go na pasta das bibliotecas, nesse caso é
um biblioteca padrão, então está no fmt.print.go que é o arquivo que contém a definição
desse método.
Você note que já me traz aqui, e é muito útil para você entender a implementação
específica, assinatura e a documentação e ver outras coisas dentro do arquivo.
Vou fechar e voltar ao meu lugar anterior.
Nós vimos que ele faz sugestões de quais métodos você pode chamar de um módulo.
Nós vimos que ele mostra também, ajuda a você entender quais são os parâmetros do
método, através de um painelzinho de assinatura de função e documentação dizendo que aqui
o método faz.
Aprendemos também como ir à definição do método para ir para o arquivo onde o método
é escrito.
Vamos fazer outra coisa aqui.
Vamos supor que eu escrevo algo com indentação errada.
O estilo foi sem indentação.
Eu vou falar fmt aqui, fonte para o trilene, indentação errada.
Agora vou apertar a control S para poder salvar o arquivo.
Você note que a indentação foi modificada logo que eu salvei o arquivo.
Então a extensão também formata o seu código fonte na maneira do Go quando e dessa
maneira você sempre terá o código na formatação correta que o pessoal do Go quer.
Também funciona para os imports, por exemplo.
Se eu importar aqui em cima algo que eu não uso, por exemplo.
E se eu colocar a indentação do espaço, se eu clicar salvar, você note que o import
não existe mais, foi removido porque nunca usamos aquele módulo strings antes e depois.
Também roda programas como o Go imports.
Agora vamos fazer algo errado aqui.
Vamos ver.
Bem, ele removeu a strings porque a gente não usou.
Mas o que acontece se eu usar strings aqui?
Eu começo a dizer certo, vou usar fmt, fonte a lene, aí vou começar a dizer strings.
Alguma coisa aqui.
Fale lá.
Join.
O que acontece aqui?
Quando eu salvei, eu não terminei a chamada da função, mas você note que quando eu
salvei arquivo eu referência strings e ele adicionou o import dos strings automaticamente
aqui na linha 5.
Isso também é uma ajuda no desenvolvimento.
Na hora que você salva ele automaticamente adiciona o import necessário.
Então dessa maneira você nunca vai esquecer de importar os módulos porque são importados
automaticamente.
Agora você note que essa linha, o strings.join e parênteses está sublinhado com a linha
vermelha.
Então se eu deixar o ponteiro do mouse sobre isso, ele está dizendo que tem um erro,
na verdade, né?
E esse erro corresponde a essa aba de problemas aqui que tem aqui embaixo, tá?
É a mesma coisa.
Eu clicar aqui ele vai para o problema e ele sublinha, né?
Então o problema aqui é que eu chamei a função join.
Não tem todos os argumentos necessários, né?
O erro é o wrong argument count, a contagem de argumentos é errada.
Você note que pela documentação leva dois parâmetros, então precisa de dois, por isso
que mostrou o erro, né?
Isso vem do...
É uma espécie de lintar, né?
Você que te disse que você fez algo errado antes da compilação, na hora que você está
escrevendo o código já te mostra que algo pode estar errado.
Então vamos consertar esse problema e posso dizer...
Eu tenho que passar um o quê?
Deixa eu ver a documentação.
Pedaço slice de string e o separador, né?
Vamos fazer aqui.
Vamos dizer aqui.
Vamos ler letras.
Dois pontos igual.
Fazer...
Fala o slice de string, né?
Literal.
A, B, C.
Vou passar isso para...
Com o primeiro argumento, o separador será a vírgula.
Deixa eu também mudar a indetação para você ver que ele também muda.
Então deu certo.
Agora não tem mais problema.
A lista de problemas agora não tem mais nenhum item.
Se você fizer qualquer problema, ele já mostra aqui.
Por exemplo, eu fiz, removi o L do PlinthLn dizendo que não é declarado no FMT,
remover o M do FMT, está dizendo nome não declarado, FT.
E se você fizer qualquer tipo de erro, por exemplo, aqui, sin taxis, né?
Esperava que tenha um erro aqui e assim por diante.
Certo?
Vamos ver esse negócio.
Você também pode executar programas com um debugger chamado delve.
Quando eu cliquei para iniciar a depuração, F5,
ele mostrou aqui que o comando DLV não está disponível, tá?
Eu não tenho ainda. Você pode clicar em install ou pode clicar em install all para instalar tudo que é necessário.
Dessa vez eu vou clicar em install all e você vê que várias coisas aqui serão instaladas.
Esses gol pkgs, gol trasload line, gol test, gol modify tags e gol play.
DLV é o delve. DLV para sudape, static check.
DLV é o debugger, né? Debugador.
Todas as ferramentas foram instaladas com exit.
Então, tentar novamente executar, iniciar a depuração.
Valeu ao continuar.
Certo, deixa eu ver o que que deu.
Abrir launch.
Certo, configurações.
Então, vamos deixar isso para a próxima aula.
Acho que já está quase 15 minutos.
A gente começou e aprendeu a instalar a extensão de gol para o visual story code vs code.
E essa extensão instala vários programas, ferramentas de desenvolvimento,
que permite facilitar o desenvolvimento de gol.
Dentro deles, a sugestão de código, documentação das funções, ir para definição de funções,
a autofamatação ao salvo arquivo, auto importar, remoção de módulos que não são usados,
variáveis não usados e assim por diante.
Então, por essa aula é só e até a próxima.


0020-05 Ambiente de Desenvolvimento IDE de Golang no Visual Studio Code com Extensao para Go

Como Debugar Codigo de Golang no Video Studio Code vscode com o Delve e Extensao Go

```markdown
# Resumo da Aula: Debugando Projetos Go no Visual Studio Code

Nesta aula, o instrutor ensina como debugar projetos em Go utilizando o Visual Studio Code (VS Code). 

## Instalação da Extensão e Delve

1. **Instalação da Extensão**: Após instalar a extensão para Go, o VS Code sugerirá a instalação do Delve (DLV), o depurador do Go.
2. **Configuração do Launch.json**: O VS Code precisa de um arquivo `launch.json` para configurar como o depurador deve ser executado.

## Configurações do Launch.json

- O arquivo `launch.json` será criado automaticamente quando você tentar debugar.
- As configurações principais estão dentro da propriedade `configurations`, que é um array de objetos. Cada objeto representa uma configuração de depuração.
- Para um projeto simples (com apenas `main.go`), o modo deve ser definido corretamente para que a depuração funcione.

## Executando e Depurando o Código

1. **Run Configurations**: Execute a configuração desejada a partir do menu de depuração.
2. **Colocando Breakpoints**: 
   - O instrutor demonstrou como adicionar um breakpoint para pausar a execução em uma linha específica do código.
   - Ao atingir o breakpoint, é possível ver o valor das variáveis na aba de variáveis.

## Navegando no Código Durante a Depuração

- **F10**: Avança para a próxima linha sem entrar em funções.
- **F11**: Entra na função chamada.
- **Shift + F11**: Sai da função atual e retorna ao ponto onde foi chamada.

## Manipulando Breakpoints

- É possível ativar/desativar ou remover breakpoints diretamente da aba de pontos de parada.
- A opção de remover todos os breakpoints também está disponível.

## Conclusão

O instrutor finaliza a aula incentivando a interação com o vídeo, pedindo likes e comentários.

---

### Observações

- O launch.json pode ser configurado para rodar arquivos específicos ou pacotes conforme a necessidade.
- O editor possibilita uma experiência de depuração robusta, facilitando o processo de desenvolvimento em Go.
```


Nesta aula vou te ensinar como debugar o projeto de Go no Visual Studio Code VS Code.
Então vamos lá.
Depois de instalar a extensão para Go do VS Code nós podemos agora debugar.
Eu tinha feito no vídeo anterior executar e iniciar a depuração o atalho F5 mas não funcionou.
Mas ele instalou o Delve.
Então quando você fizer isso clicar aqui pela primeira vez ele vai sugerir que você instale o DLV Delve que é o debugador do Go.
Então você pode clicar para instalar e depois instalar todos os pacotes necessários.
Vamos aqui ver o que acontece.
Então meu caso falhou.
Ele não sabe como rodar o debugador porque ele só tem um arquivo main.go e não está dentro de um modo definido pelo arquivo go.mode.
Então ele realmente não sabe como rodar isso.
Então o vscode tem um arquivo chamado launch.json que tem as configurações para poder que ele usa quando rodar o debugador.
Eu vou clicar aqui no Go launch package para criar um.
Esse arquivo vscode bar launch.json que é criado aqui na minha pasta do projeto.
Ele criou com essa configuração aqui.
Bem então é um arquivo.json tem que abrir chave tem certas propriedades o que importa é configurations.
Uma array aqui de um objeto que define uma configuração que vai aparecer aqui se você clicar no debugador.
Você tem várias opções essa opção que aparece aqui corresponde a esse objeto aqui definido no launch.json.
Só tem um agora que corresponde a launch package.
Note que o name define o nome que aparece aqui nessa lista de drop down.
Note que eu cliquei na A no ícone de debugador executar e depurar o atalho é control chef de D.
Bem vamos dar um olhado nisso bem o name é aquele que aparece na tela então type go você deixa assim mesmo request a launch certo.
O modo de automático alto deixa assim mesmo program vai ser o caminho daquilo que vai rodar.
Nesse caso está se referindo a essa variável aqui nesse place hold chamado file de nome.
Agora esse file de nome corresponde ao diretório em que o arquivo por exemplo eu cliquei em em português eu rodei daqui.
Esse arquivo está dentro de uma pasta essa pasta é que aparece aqui nesse vai ser o caminho para pasta.
Mas como não tem um projeto definido com o golmode então deu o problema aqui então o que que eu vou fazer e veio de rodar da pasta
toda só vou rodar no arquivo presente que está aberto nesse caso eu poderia modificar essa configuração
ou eu posso copiar e colar e criar uma nova configuração para poder preservar essa que isso que eu vou fazer adicionar vírgula copio objeto.
Nesse caso vai ser talvez file o arquivo qualquer nome que você quiser que apareça aqui tá deixa eu salvar esse arquivo mas antes do program invade file de nome vai ser file.
Quando você coloca file ele corresponde o caminho do arquivo que está aberto isso que a gente quer rodar o debulador no arquivo que está aberto.
Noto que meu caso é bem simples só tem um arquivo mas no caso de outros do seu projeto que tem vários arquivos você vai querer usar esse outro aqui e você vai ter que definir o golmode e tal e para que funcione ele que funciona e corretamente.
Vou salvar arquivo note que agora quando eu clicar na aba do debulgador na drop down aqui.
Tem também um long file o novo item que eu adicionei.
Então de volta o arquivo main.gol eu posso que ou posso usar a drop down selecionar long file e clicar o botão de play.
Note que ele rodou a bc.
Olamundo inetação errada e assim por diante.
Se eu clicar executar f5 também funciona da mesma maneira.
Agora vamos aprender como colocar um breakpoint para poder a gente debugar.
Antes disso eu tenho que para demonstração vou criar uma nova função aqui.
E essa função vamos ver.
Vou pegar letras aqui cortar.
Vou retornar o string join letras dessa função.
Return string.join retornar o que lembra do debutar o nome para ver a assinatura da função essa função aqui retornam a string.
Então o fazer algo também vai retornar uma string.
Coloquei o string ali.
Agora vamos ver.
Eu vou chamar o fazer algo aqui.
Print ln.
Vamos ver o que posso fazer.
Na verdade deixa eu colocar no variável.
Vai a mensagem tipo string e vou dizer que mensagem é fazer algo.
Colocar assim.
Se você quer fazer algo que está dando.
Que clararam mas não usaram certo.
E aqui eu vou colocar mensagem.
Vamos supor que eu queira saber qual é o valor de retorno de mensagem.
Posso colocar um ponto de breakpoint aqui na linha 16.
Ele pode parar aqui.
Logo após a execução da linha 15 que vai definir mensagem.
Vamos rodar a long file f5.
E ele vai pausar a execução do programa na linha 16 que tem o breakpoint.
Você note que do lado esquerdo tem uma aba variáveis no caso variável local tem mensagem que o valor é abc.
Mostra também a stack pilha de chamadas.
No meu caso estou rodando da função main.
E o resto é a stack.
E aqui os pontos de parada.
O breakpoint.
No meu caso só tem um.
A linha 16 do arquivo main.go.
Bem então já sei que mensagem e abc esperavam ver isso certo.
Também posso usar aqui essa terminazinha aqui embaixo com o sólido de depuração e posso dizer o nome da variável enter e ele também mostra o valor aqui.
Para poder continuar para o próximo ponto de parada breakpoint f5.
Deixe eu rodar o debugger de novo para te mostrar como é que eu posso e linha por linha.
Linha por linha é essa segunda ícone aqui o chamado contornar o atalho é f10.
Aperta f10 e ele vai para a próxima linha próximo statement né.
F10 de novo.
Validinha 19.
Esse por diante.
Continuar para aí.
Vamos adicionar um ponto de partir o ponto de parada aqui na linha 9.
E vamos rodar de novo.
Note que ele parou primeiro na linha 9 da função fazer algo porque foi chamado da linha 15.
Então ainda não chegou na linha 16.
A linha aqui.
Note que a variável local não tem letras ainda porque ele parou antes da execução do statement da linha 9.
Para poder o letra ser definido a gente teria que ir para a próxima linha.
Próximo statement.
Isso é o f10 porque não tem breakpoint na linha 10.
Mas é claro que se você adicionasse o breakpoint na linha 10 e clicasse o f5 continuar iria para a próxima linha.
Mas se você não tiver ponto de parada na próxima linha é só dar o f10 que ele vai para a próxima linha.
Você note que na aba de variáveis propriedade local temos agora letras.
Se você expandir temos um array um slice de string tem três elementos primeiro a segundo b e terceiro c.
Certo.
Se eu clicar no continuar ele vai para o próximo ponto.
Se eu clicar f10 vamos ver o que acontece.
Então ele volta.
Vai para o próximo statement que é a atribuição aqui.
De o valor retornado fazer algo a mensagem.
Note que o mensagem não tem nada ainda porque a linha de atribuição não executou ainda.
Eu posso falar o continuar para a próxima linha que tem um ponto de parada.
E agora a mensagem está definida.
Se você quiser parar tudo e não quiser continuar para o próximo ponto pode dar o enterro p shift f5.
Agora vou te mostrar também como é que entra no fazer algo sem ter o ponto lá.
Então eu vou colocar aqui na linha 15 um ponto de parada e eu quero entrar na função fazer algo.
Entrar no chamado em vez de ir para a próxima linha que é 16 eu quero entrar na execução de fazer algo.
Vamos fazer isso. Vamos lá clica play para debugar.
Então você note aqui se eu apertar o f5 o que acontece.
Ele termina porque não tem mais nenhum ponto.
Ele vai para o final executa tudo.
Se eu dar o f10 ele vai para a próxima linha que é 16.
E isso não vai para o fazer algo.
A definição é para o final executa tudo.
Isso não vai para o fazer algo.
A definição é implementação.
Note que tem outra opção aqui f11 e a opção de shift f11.
Então vamos ver o que acontece eu da o intervi f11.
Note que agora ele entrou aqui.
Eu da o f10.
Ah, então está indo na implementação de fazer algo.
Letra definida. Se eu dar f10 volta para lá.
Agora se eu dar vou parar e vou reiniciar para te mostrar como é que sai da função.
Então vamos lá de novo. Vou entrar no fazer algo com f11.
Entra na função na definição.
Eu posso dar o f10 para a próxima linha e se pude antes.
Mas agora eu queria sair do fazer algo sem ter que ir para a próxima linha.
Como é que faz isso? Vai ser esse ícone de sair.
Shift f11.
O quarto ícone da esquerda para a direita que é a seta indo para cima.
Se eu clicar nesse ícone ele vai sair da implementação e volta para onde foi chamado.
Eu posso fazer isso também com o println.
Vamos ver o que acontece.
Eu vou dar f10 para ir para a próxima linha. Eu quero entrar no println.
Eu vou dar o f11 para intervir. Agora eu estou dentro do println. Olha só.
Que legal. Eu posso ver aqui que tem os argumentos nas variáveis locais n e a.
Se eu dar o f10 para ir para a próxima linha.
O n é zero e não tem erro.
Se eu quiser sair o.
Shift f11 e volta para lá.
Tá.
Eu vou parar aqui. Você pode se tiver vários pontos.
Aparece aqui do lado aqui abaixo na aba de pontos de parada.
Se você quiser desativar é só clicar no check no checkmark aqui nessa caixa de.
Pois é. Se você checar significa que vai executar o breakpoint para desativar e não.
E para esse breakpoint você pode desmarcar.
Se você quiser realmente dela é tal o ponto de parada interrupção é só clicar no X.
E também a remover todos remover todos os pontos se você não quiser clicar um por um.
E pronto não tem mais nenhum.
Não tem várias coisas aqui bem legal no divulgador.
Então voltando que era antes.
No pasta.vscode barra o arquivo launch.json define essas.
Opções de rodar o divulgador.
Nesse caso tem a.
A propriedade configurations que é um array de várias.
Configurações.
Vários itens para ser rodado no divulgador que aparece aqui.
Já tinha já foi criado automaticamente o launch package.
Quando a gente tentou rodar o divulgador.
Mas isso não funciona no meu caso porque é um arquivo.
Sem ter ser parte de um projeto com arquivo GoMod então não é funcionar para mim para rodar o caminho da pasta em que o arquivo presente.
Está dentro.
Então eu tive que mudar em vez de referenciar o caminho da pasta.
Eu referenci o caminho do arquivo que está aberto com o programa definido com o dólar.
Abri chave.
File fecha chave.
Com isso aparece uma nova launch file nesse caso aqui rodar arquivo que eu criei.
Você pode mudar o nome.
Não precisa ser o mesmo nome.
Parece qualquer nome que você queira que aparece aqui.
Por isso por essa aula é só.
Espero que tenha gostado.
Não se esqueça de dar o seu like.
Deixe comentário e até a próxima.
Até a próxima.


0020-06 Como Debugar Codigo de Golang no Video Studio Code vscode com o Delve e Extensao Go

Escrita de Código de Golang do Navegador no Go Playground

# Resumo da Aula sobre Go Playground

Nesta aula, o foco é no Go Playground, acessível pelo site [play.golang.org](http://play.golang.org). O Go Playground permite que os usuários escrevam e executem código Go diretamente no navegador.

## Funcionalidades do Go Playground

- **Execução do Código**: Você pode digitar seu código e clicar em "Run" para executá-lo. O exemplo exibido, imprime "Hello Playground".
  
- **Formatação do Código**: Há um botão "Format" que corrige a indentação e formata o código de acordo com os padrões do Go. Isso inclui a remoção de espaços desnecessários e a ordenação dos imports.

- **Gerenciamento de Imports**: Quando um import não é utilizado, o Go Playground remove automaticamente. Se você usar um import e esquecer de referenciá-lo no código, ele também pode adicioná-lo automaticamente.

- **Compartilhamento de Código**: O botão "Share" permite que você compartilhe seu código gerando um link que salva o código no servidor do Go Playground. É importante evitar o uso de informações sensíveis devido ao armazenamento no servidor.

## Limitações e Cuidado

- **Segurança**: É aconselhável não inserir informações confidenciais (como senhas ou tokens), pois o código é salvo no servidor.

- **Conexões e Performance**: O playground não suporta conexões externas e pode limitar programas que consomem muitos recursos, resultando em falhas.

- **Múltiplos Arquivos**: É possível simular múltiplos arquivos, utilizando um formato especial na entrada de texto, embora a criação de pacotes diferentes do principal possa ter limitações.

- **Data e Hora**: As funções relacionadas à data retornam um timestamp fixo de 2009, então deve-se ter cautela ao usar funcionalidades de data no playground.

## Conclusão

O Go Playground é uma ferramenta útil para experimentar e aprender a linguagem Go. Acesse [play.golang.org](http://play.golang.org) para explorar suas funcionalidades.

Nesta aula vou falar do Playgrounds.go.
Se você for para o site play.goalang.org, nos deparamos com esta página que é um Playground
.go.
Isto é, você pode digitar o código e ver e executar através do navegador.
Então já tem um código aqui preparado.
Você pode escrever o código aqui, o navegador e quando for na hora de rodar, só clicar
Run.
Ele vai rodar o código no servidor e vai ativar a resposta aqui.
Neste caso, este programa imprime as palavras Hello Playground.
Então é bem legal, vou te mostrar a funcionalidade do Playground aqui.
Por exemplo, vamos supor que eu esqueci de formatar a indentação e eu fiz alguma coisa
totalmente fora de estilo.
Adicionei os espaços antes e depois de funk e removi a indentação da linha 8.
Tem este segundo botão da esquerda para a direita, chamado format, que vai formatar
o código da maneira do Go.
Ele remover os espaços e formatou usando o tab tabulação.
Vamos ver outra coisa aqui.
Vamos ver esta parte aqui do import.
Ele vai usar o Go import, mas o que é isso?
Vamos ver.
Então se eu dar outro import aqui, por exemplo, strings aqui fora em outros import separados,
se eu clicar esta checkbox aqui, marcar e format, note que ele removeu o import dos
strings porque eu não usei nenhum método do módulo strings.
Vou reverter isso e deixo eu dar um import de novo, mas eu vou usar os strings para
ver o que acontece agora.
Eu vou dar aqui embaixo.
Vamos ver strings.join.
Deixa eu criar aqui três strings numa fatia slice.
Vamos dizer letras, dois pontos igual.
Slice de string, abre-chave, abce.
E vamos passar com primeiro argumento join e vamos separar.
Vamos combinar essas três strings em uma só com a vírgula entre cada um.
Aí vamos dar fmt.println nisso.
E vamos clicar format.
Olha agora o que aconteceu.
Além do espaço de indentação com a tabulação, na verdade tabulação, ele adicionou aqui,
ele combinou os imports em um só.
Na linha 5 agora tem strings e também está ordenado por alfabeticamente.
Legal.
Mas o que aconteceria se eu não tivesse importado strings?
Vamos ver se ele também é esperto nesse aspecto.
Ah, então ele adicionou o import que eu tinha removido.
Então se você usasse strings aqui e esqueceu de importar, ele também corrigiu isso.
Certo?
O quarto botão da esquerda para a direita aqui é share, é para compartilhar o código.
Então você pode clicar nesse botão e ele vai adicionar esse sufixo na URL que serve
para você copiar esse link e enviar para outras pessoas.
Note que esse código vai ser salvo no servidor do Go Playground.
Então tome cuidado nas coisas que você escreve aqui.
Go Playground é só para coisas, para você tentar fazer umas coisas bem rápido, mas
não deve ser coisa que envolva algo, informações preciosas, informações confidenciais.
Então não põe negócio de senha, token e várias coisas privadas, informações pessoais.
Então põe aqui isso porque vai ser salvo no servidor e pode alguém algum dia se aquear
o servidor, alguma coisa, pode roubar informação.
Então tome cuidado, use com cuidado isso aqui, só para aprendizado mesmo, para tentar
coisa bem rápida.
Vale também ressaltar que não tem...
Você tentar fazer alguma coisa que envolva conexão, módulo de conexão, não vai funcionar.
De você tentar consumir muita memória através da escrita de um programa pesado e processos
longs também, você não vai funcionar direito porque o servidor vai parar exacção porque
está muito pesado.
Você talvez tenha tentado fazer algo maliciosa para poder derrubar o servidor e tal.
Aí ele vai pensar que foi isso.
Certo?
Outro detalhe também, você pode criar outro arquivo.
Aqui a gente só tem um arquivo, mas se você quiser, dá para simular a criação de um
segundo arquivo se você adicionar aqui traço traço o nome do arquivo, por exemplo.
Sei lá.
Soma.go e adicionar a função aqui.
Na verdade package.
Package soma.
Pack.
Adicionar.
A, B, int.
int.
Retornar.
Plus.
A mais B.
Vamos ver o que dá isso se eu pegar aqui nesse arquivo principal e tem outro arquivo chamado
soma.go.
Você pode referenciar essa pacote aqui.
Vamos ver se funciona mesmo.
Se eu falar soma.adicionar 2 e 3 e dá o fmt nisso.
fmt.front.ln.
A soma.adicionar 2,3.
Vamos ver se funciona.
Package name must be main.
Parece que não deu certo ali.
Pacote.
Deixa eu ver aqui.
Talvez o playground não suporte, mas deixa eu tentar outra coisa aqui.
Se eu mudar o nome do pacote para soma e remover soma.ac.
Funcionou nesse caso.
Parece que não dá para criar outro pacote que não seja main.
Mas foi um arquivo separado.
Simulado e adicionado até lá.
Tras, traspas, nome do arquivo, espas, trastras e tudo abaixo disso é conteúdo do
arquivo do outro arquivo.
Tá bom.
Outra coisa, um negócio de data.
Se você tentar usar data e o playground, vai ter uma data que não é
atual, mas a data em que o Go começou em 2009, novembro de 10, 23 do 3.
Então, com cuidado se você tentar fazer algo com que envolva datas e hora no
playground, pode ser que dê algo estranho porque a data está ajustada para 2009.
Então, é bem isso.
Esse é o Go Playground.
Visite play.golang.org para poder brincar nesse playground.
Espero que tenha gostado dessa aula e até a próxima.


0020-07 Escrita de Código de Golang do Navegador no Go Playground

Escrita de um Makefile e o Uso do make no Desenvolvimento de Programas de Golang

# Resumo da Aula sobre Makefile

## Introdução
- A aula apresenta o **Makefile**, uma ferramenta tradicional no desenvolvimento de software.
- O foco é na automação do processo de criação de builds, especialmente para projetos em **Go**.

## Ferramentas Utilizadas
- **IDE**: Visual Studio Code (VS Code) com extensão do Go desativada para demonstração.
- **Comando Make**: Usado para automatizar e simplificar a execução de tarefas.

## Demonstração Prática

### 1. Criação do Makefile
- Criação de um arquivo chamado `Makefile`.
- Primeiro alvo implementado: **FMT** para formatar o código utilizando o comando `go fmt`.

### 2. Configurando Dependências
- O segundo alvo implementado: **VET**, que depende do alvo **FMT**.
- O terceiro alvo adicionado: **IMPORTS** para corrigir importações faltantes, dependendo de **FMT** e adicionado por último ao fluxo.

### 3. Implementação do Build
- Alvo final: **BUILD**, dependente do alvo **VAT**.
- **Alvo Padrão**: O Makefile pode definir um alvo padrão usando a variável `.DEFAULT_GOAL`.

### 4. Comandos e Execução
- Explicação sobre execução dos alvos em sequência:
  - Ao executar `make`, a sequência de tarefas conforme as dependências é realizada.
  - Demonstração de erro corrigido no código usando o comando **Import**.

### 5. Criação e Verificação do Executável
- O executável é gerado com o comando `go build`.
- Uso do Makefile economiza tempo ao evitar recompilar arquivos que já estejam atualizados.

## Conclusão
- O **Makefile** permite a automação do processo de builds, contribuindo para uma melhor organização e eficiência.
- Applicável não apenas em Go, mas em diversas linguagens e processos de desenvolvimento. 

--- 
Espero que você tenha gostado dessa aula sobre o básico do uso do Makefile para automação de builds. Vejo você na próxima!

Olá pessoal, bem-vindo a mais uma aula.
Nesta aula eu gostaria de falar de uma ferramenta bem tradicional, um mundo de desenvolvimento
de software, mas que eu acho que vai ajudar a automatizar o processo de criar um build.
Eu vou falar de Makefile.
Você já ouvi falar do programa comando Make, M-A-K-E, disse que a gente vai falar.
Embora que a IDE passa, por exemplo, no meu caso, estou usando do lado esquerdo da tela o
vejo Studio Code, que já tem a extensão do Go.
E a extensão faz as coisas para a gente automaticamente, por exemplo, se eu salvar o meu arquivo, ele vai formatar
no estilo padrão de Go automaticamente esse tipo de coisa.
Mas para quem gosta mais de automatizar na linha de comando e também isso ajuda a fazer script
para a integração continua, TI, CI.
Então vamos lá.
Para esta aula, desativei a minha extensão do Go para que não salve o arquivo comate automático.
Eu gostaria de demonstrar o seguinte, o uso de um Makefile para poder criar um build,
esse programa aqui, programa bem simples, um arquivo que eu criei chamado principal.go,
do lado esquerdo da tela, que está o arquivo que está aberto.
Você note que há uns problemas de formatação nesse arquivo.
Eu tinha até algo.
Até esqueci de importar, está outra coisa aqui.
Então vamos fazer o seguinte, vamos automatizar o processo para criar um build,
mas antes de fazer build com Go build, vamos rodar GoVet, vamos rodar o FMT para formatar o código.
Eu note que o código está com um formato que não é padrão, não está mostrando aqui.
Estes aqui são espaços, dá certo?
Vou mudar as configurações do VS Code para mostrar esses.
Posso mudar aqui para all, render white space, para eles sempre mostrar os caracteres invisíveis.
A norte que o ponto aqui está vendo, que aparece esse ponto em por cinza,
ponto significa espaço em branco, não é uma tab, a tab é o padrão de indentação do Go.
A norte que o 6 tem a tab corretamente, que essa seta apontando para a direita,
significa que tem uma tab aqui, se eu botar espaço, vira esses pontos no VS Code.
Então vou criar um arquivo chamado Makefile, certo?
Com o primeiro M Myosco, no Makefile vou fazer o seguinte, vamos primeiro começar só pelo FMT.
Então eu quero criar esse alvo chamado FMT, certo?
Eu vou dizer FMT, o nome do alvo, dois pontos e os pré-requisitos desse alvo.
Nesse caso aqui não tem pré-requisito, então eu vou deixar em branco.
Na próxima linha você tem que botar uma tab, indentação.
Nesse caso eu tenho o Makefile selecionado aqui, o VS Code, então ele automaticamente adiciona tab
em vez de espaço em branco quando aperto tecla tab.
Ah não, é espaço em branco, é tab mesmo.
Eu vou dizer como que se cria ou se gera esse alvo.
Eu vou dizer Go, FMT, eu vou deixar as coisas bem simples, só vai ser um arquivo mesmo, principal.go.
Então no mundo de Makefile a gente diz os alvos, normalmente seria um arquivo que seria gerado a partir de certo pré-requisitos
e então depois de conseguir esses pré-requisitos a gente executa os comandos que seguem nas próximas linhas com a indentação.
Então o alvo aqui seria o FMT, dois pontos não há nenhum pré-requisito, então é em branco depois dos dois pontos
e a gente vai rodar o comando Go FMT para formatar o arquivo.
Então a gente pode testar isso na linha de comando aqui.
Como eu estou usando o Linux, ele já vem com o Make, você vai dizer Make, espaço, traço, traço, verger,
eu estou usando o Guino Make, quatro pontos dois, ponto um.
Os usuários de Windows não têm Make por padrão, então você teria que instalar.
Eu recomendo instalar através do chocolate, você vai lá no site do chocolate,
você ainda não tiver, é só baixar aquele script, instal.ps1, ele morta lá.
Na verdade ele manda você copiar o código, você abre o PowerShell com o administrador,
e você cola aquele código que ele te diz na página do chocolate, aí ele vai instalar.
E depois para só abrir uma nova linha de comando, cmd.se, comandemestador, editado, show, com install, Make.
E depois você vai abrir uma nova janela de cmd e vai dar para usar o Make.
Com o Make instalado a gente pode fazer o seguinte, se você falar só o Make,
ele vai buscar o Make file no diretório presente aqui que eu tenho, e vai rodar a primeira tarefa ou algo.
O que achar, nesse caso é FmT.
Você nota que ele roda o comando, e se eu olhar o meu arquivo, você nota que ele já formatou tudo, na maneira padrão do Go.
Os espaços foram convertidos para tabs, a indentação foi corrigida,
e ele até fez, adicionou esses espaços aqui na minha definição dos campos da struct.libro.
Também adicionou espaço, a esquerda e a direita do operador, nesse caso de comparação de dois números, se é igual.
Isso é o FmT, vou reverter só para você ver o que era antes, e depois do FmT, a gente já viu isso, vou deixar reverter.
Também você quiser dizer Make, pode dizer o Alvo específico, por exemplo, Make é FmT, ele vai rodar FmT.
Claro que só tem FmT aqui, mas se você tivesse outros Alvos, poderia fazer.
Uma coisa a adicionar aqui é dos Alvos, é sempre bom, no caso que o Alvo tradicionalmente, por exemplo, os Alvos seriam nomes de arquivos.
Por causa disso, o Alvo seria as instruções ou uma receita para você poder criar esse arquivo especificado antes dos dois pontos.
Como a gente não tem a geração de arquivos, por exemplo, de objetos, quando a gente compre um código-fonte, o FmT, que na verdade não é um arquivo, que é gerado.
A gente só modifica o principal.go.
Tá certo? Então, a gente vai adicionar esse negócio chamado FmT, ponto FmT, esse Alvo aqui especial, ponto FmT, dois pontos, e o nome do Alvo que a gente quer que seja FmT.
FmT significa que não é, como se fosse algo que não é autêntico. Nesse caso, FmT não é um arquivo que é gerado.
Então, para a gente poder dizer para o Make, para que a gente não vai gerar nenhum arquivo chamado FmT, a gente fala ponto FmT, dois pontos, e o nome do Alvo que vai ser FmT.
Isso vai prevenir qualquer conflito entre arquivos.
Se tiver um arquivo FmT na mesma parte, ele não vai ter conflitos se você dizer que é FmT aqui.
Também vai melhorar em termos de performance, porque tem esse lance, esse Make ver que o arquivo já foi criado.
Por exemplo, se tivesse um arquivo FmT sem esse pône, aí ele não iria executar o comando aqui essa tarefa.
Por exemplo, se eu fazer touch FmT, na verdade, criar um arquivo chamado FmT e tentar order o Make, aí ele vai dizer que o FmT está atualizado porque ele viu FmT, certo.
Esse arquivo existe, então não preciso fazer mais nada, já está feito.
Então, para poder não ter esse conflito, você escreve ponto fmt, dois pontos, e o nome do Alvo nesse caso é FmT, ele vai fazer o Make, vai rodar de novo, ainda que o arquivo exista.
É importante isso.
Então, com isso legal, vamos fazer outra coisa?
Então, temos FmT legal.
Eu quero também fazer o VAT, vamos falar VAT.
Agora, é claro que eu sei que o VAT vai ser o quê? Go, VAT e o nome dos arquivos.
Mas, eu quero fazer o seguinte, eu quero que essa tarefa VAT dependa de outra tarefa, isto é, para poder fazer o VAT, você tem que primeiro fazer outra tarefa, ou tarefas.
Nesse caso, eu quero que o VAT dependa do FmT.
Então, o Alvo VAT primeiro vai ter como pré-requisito o FmT.
Agora, como é que faz FmT?
Então, ele vai pular para a linha 4, vai ver, o FmT depende de alguma coisa ou não?
Está em branco, depois de dois pontos.
Então, vai executar a Go FmT, principal ponto Go.
Depois disso, terminou a tarefa FmT, volta lá para linha 1 e não tem mais pré-requisito.
Nesse caso, só tem um que é o FmT.
Com isso, você pode começar a execução do VAT, que é na linha 2 e em diante.
Então, ele vai falar Go VAT, principal ponto Go.
O Alvo VAT depende do FmT.
Para poder executar as linhas do VAT, preciso primeiro executar as linhas do FmT,
que pode até ter uma pré-requisito, mas nesse caso não tem.
Então, a gente vai fazer também fone nesse caso, ponto pone, porque o VAT não é um arquivo que será gerado.
É um ponto fone, dois pontos, VAT, para não ter aquele conflito.
E se eu dizer make, agora, o primeiro tarefa que encontrado no arquivo é o VAT.
Então, se eu dizer make, sem dizer VAT, ele vai rodar o tarefa VAT.
Então, você note que o primeiro roda o FmT, porque é dependência, depois diz roda o VAT.
Aí, quando a gente rodou o VAT, ele teve um problema.
O arquivo tem na linha 16, o que eu fiz errado.
Ah, é.
O FmT não foi importado.
Qual é aquela ferramenta que a gente pode usar para poder automaticamente importar as coisas que foram esquecidas?
Tem um Go Import.
A gente poderia adicionar o Go Import como dependência do VAT para poder corrigir isso.
Vamos lá, então.
Então, como é que faz para adicionar a dependência aqui?
Bem, você poderia depender um, depender de outro, e um depender de outro, ou você pode ter várias dependências.
Então, eu posso adicionar um adicional aqui.
Nesses casos, depois de FmT, qual seria outra coisa? Seria o Go Import.
Então, eu vou falar importos.
Ou Go Import, o que você quiser.
Qualquer nome.
Então, eu vou dizer que importos, dois pontos, não depende de nada.
Eu vou dizer Go Import, principal, ponto Go, mas eu acho que o Go Import tem que dizer...
Se você só falar Go Import, ele não vai modificar o arquivo.
Então, tem que dizer a opção traço W para poder modificar o arquivo.
Já tem também a opção traço W para dizer que o arquivo foi modificado.
Então, nesse caso aqui, o VAT, quando eu falar VAT, vai depender de FmT primeiro e vai executar FmT, vai depender do import, vai executar o import.
Claro que eu também poderia separar isso e fazer o seguinte.
Poderia deixar o VAT primeiro depender do import, que o import dependeria do FmT em sequência.
Mas eu quero deixar mesmo para Mute para você aprender que não precisa só de um pré-requisito.
Pode ter vários.
Vamos ver o que dá esse negócio aqui.
Ah, também ponho o powne, ponto powne.
Antes ou depois, não importa, certo?
Pode ser antes ou depois.
Puta, antes aqui para você ver que não importa.
Powne, import.
Porque import não é um arquivo que vai ser gerado, então a gente põe o powne para não ter nenhum conflito e para funcionar o make funcionar sem problemas.
Vamos lá falar make.
Vamos ver aqui.
Então, note que primeiro rodou FmT, depois rodou import, depois rodou o VAT.
Vamos revisar de novo.
O alvo VAT depende de dois alvos FmT em portes.
Primeiro vai para o alvo FmT.
Começa o alvo FmT.
Tem alguma dependência depois de dois pontos?
Não.
Então, executa as linhas seguintes.
Volta lá para a linha 1, terminamos a tarefa FmT, a próxima alvo é import.
Vamos lá para o import, se depende de alguma coisa ou não.
Em branco, depois dos dois pontos.
Executa as linhas seguintes, então.
Executou o gol em portes.
Volta lá, acabamos as dependências, podemos executar todos os comandos do VAT na linha seguinte.
Então, deu problema na linha 17, o VAT identificou um problema.
Aqui foi a linha 17.
Eu esqueci de estar dizendo que não tem.
Os argumentos são na verdade, precisar de mais de um.
Para o John, preciso dizer, join as strings em que ter limitado o que é separado.
Posso botar em branco, barra, vígula, qualquer coisa.
Salvar, dar o make, de novo, funciona sem problemas.
Agora, não criar ainda build, certo?
Então, vamos lá.
Agora, depois de identificar problemas, podemos criar finalmente a build.
Eu vou falar build como algo, e a build vai depender do VAT.
E o VAT depende de FMT em portes, então não precisa dizer FMT em portes aqui no build, certo?
Ele já depende do VAT, que depende do FMT e do import.
Para poder fazer a build, na próxima linha tab, gol, build, o nome do arquivo principal, principal.go.
Eu tinha dito que o primeiro alvo que encontrar no arquivo de cima para baixo
é que o make vai usar como padrança quando você fala make na linha de comanda.
Se você quiser, eu poderia botar o build lá para o final,
se eu botar o build lá no final, nunca iria executar o build, a não ser que eu falasse make build.
Se eu quiser que o build seja o padrão, em vez do primeiro que encontrar, na linha 4VAT,
eu posso atribuir a variável aqui para dizer qual é que vai ser o alvo padrão, certo?
Vamos fazer isso da maneira assim.
Chama gol, o objetivo.
Ponto default, gol, passo, dois pontos igual e o nome do alvo que é build.
Ponto default, gol, a gente atribui build.
Nesse caso ele vai setar quando você fala make sem nada, sem nenhum argumento na linha de comanda,
ele vai automaticamente usar o padrão que é build.
Você vê o FMT, impostos, VAT, finalmente build.
Por que o build está no final?
Se lembra, porque o build depende do VAT e do FMT e do import.
Build, primeiro order da penicia VAT, pronto, FMT.
Terminou a penicia FMT, vai para imports, order imports, terminou.
Pronto, roda o VAT, pronto, volta para requisito do build, terminou, roda o build.
Não tem nada a ver com o build estar no final do conteúdo do arquivo.
E também pode pôr fone no build que não existe em um arquivo chamado build.
Ponto fone, build, dois pontos build.
Se eu dar o LS, ele criou o arquivo principal na diretória presente.
Tem um lance que você note que sempre que eu falo make, ele roda o comando de novo.
Mas se lembra que aquele conflito do arquivo que antes tinha, que ele não rodava o negócio normalmente, porque o arquivo já existia.
Você pode usar aquilo na verdade que se você tiver certeza que o principal aqui estiver acompilado
e você não quer rodar de novo, você tem certeza que ele vai ver que já tem aí.
Mas como faz isso? Você pode dizer o nome desse arquivo como alvo, por exemplo.
Se você vai adicionar o principal como alvo e ele der pd de build, olha só.
O nome do alvo vai corresponder ao nome do arquivo e não tem fone.
E o principal depende de build, então ele vai fazer tudo no caminho do build e esse vai ser como gerar o arquivo principal.
Nesse caso, não tem nenhum comando de baixo aqui nas linhas seguintes.
Então se eu fizer make, não, mas que não identificou.
Ah, porque foi o build. Eu quero falar make principal para ele rodar o alvo principal.
Eu esperava que ele já iria dizer que já tinha criado. Ah, porque não foi.
Se eu mudar build para principal, vou colocar principal aqui.
Talvez seja porque eu tenha que rodar o build como comando principal.
Então vou fazer isso de maneira. Então eu mudei build, então o nome e eu tenho que tirar o fone.
O nome do arquivo que vai ser gerado é principal, depende de vet e tal e os comandos é golbuild, não sei o que.
Se eu falar make, fone sem principal, roda uma, roda outra.
Interessante que ele não faz o fone.
Se você souber que não está funcionando como eu queria, só este comentário aqui.
Mas o que eu queria fazer é demonstrar que se o arquivo já tivesse compilado, ele não faria o make de novo.
Isso que normalmente para você economizar na performance e no tempo.
Então normalmente se o arquivo, no caso se fosse arquivo de estava compilando e gerasse arquivos de objeto, por exemplo, e se eu tipo as plas.
O nome do arquivo.o seria os alvos.
E se eles já tivessem sido criados, gerados e não houvessem modificação, ele não iria compilar de novo, ele iria apenas reutilizar.
De qualquer maneira, e eu espero que você tenha gostado dessa aula.
Você pode fazer mais pra você sobre make, mas esse é o básico, o básico do básico.
Para automatizar o processo de criar builds.
Na verdade o make você pode fazer usar para não só para golang, para colocar linguagem, ou até para coisa que não é relacionada.
Programação, para gerar qualquer coisa baseada na dependência, alvos e comandos e por diante.
Tá bom, então por essa aula é só.
Eu te vejo na próxima.


0020-08 Escrita de um Makefile e o Uso do make no Desenvolvimento de Programas de Golang

Versões Diferentes de Golang na Mesma Máquina e Preparação para Upgrade

```markdown
# Resumo da Aula de Golang

Olá pessoal, estamos de volta com mais uma aula sobre Golang. Nesta aula, discutiremos as diferentes versões do Golang e como elas podem afetar seus programas.

## Problemas com Atualizações de Versão

Quando você atualiza a versão do Golang instalada no seu sistema, pode ocorrer de seu programa começar a falhar devido a mudanças na nova versão. Isso, no entanto, não ocorre com Golang, pois:

- Os executáveis do Golang já incluem o *runtime* e bibliotecas essenciais, o que significa que não dependem de versões externas do SDK. 
- Isso permite que diferentes programas rodem versões distintas do Golang simultaneamente sem interferência.

Por exemplo, você pode ter:

- Uma API rodando na versão 1.36.5
- Um outro serviço na versão 1.17.3

## Instalando Múltiplas Versões do Golang

Para verificar se seu programa funcionará na versão mais nova do Golang:

1. Verifique a versão instalada (`1.16.5`).
2. Instale a nova versão (`1.17.3`), que não sobrescreve a versão anterior, apenas a adiciona:
   ```bash
   go install golang.org/dl/go1.17.3@latest
   ```
3. A nova versão será instalada em um diretório específico, acessível via comando:
   ```bash
   go1.17.3 download
   ```
4. Para rodar um programa com a nova versão, apenas utilize seu executável:
   ```bash
   go1.17.3 build
   ```
5. Execute e teste seu programa para verificar se não houve quebras.

## Substituindo a Versão Padrão

Se você decidir substituir a versão padrão:

- Você pode excluir a versão antiga na sua pasta pessoal e instalar a nova versão, utilizando os métodos apropriados para seu sistema operacional (Windows, Mac ou Linux).

## Considerações Finais

- Ferramentas e comandos de desenvolvimento mudam frequentemente, portanto, esteja atento a alterações nos comandos do Golang.
- Sempre teste seus programas antes de fazer atualizações definitivas.

É isso por hoje! Até a próxima!
```

Olá pessoal, estamos de volta com mais uma alva de Golang.
Nesta aula eu gostaria de falar sobre versões diferentes de Golang.
Imagina o seguinte, em geral, se você tivesse um programa rodando na sua máquina e uma
certa versão do seu linguagem de programação.
O SDK software development kit.
E aí você quisesse instalar a versão mais nova que acabou de sair e tal fazer um upgrade.
Você faz o upgrade e o negócio programa começa a falhar.
Porque na nova versão teve uma mudança que quebrou seu programa.
E aí isso acontece em Gol.
Então isso não é acontecer em Gol.
Por que? Vamos falar disso.
Então os programas executáveis de Gol tudo já é embutido.
Nesse caso o runtime da linguagem, runtime do Gol, as funções básicas, biblioteca,
plaidrão, etc.
E aí embutido não é executável.
Isso significa que não precisa ter as bibliotecas separadas no computador para poder rodar o seu programa.
Isso tudo já é incluído no executável.
É claro que se tiver isso, claro que o arquivo tamanho vai ser maior.
Mas o benefício é que não vai quebrar se o SDK que está instalado no seu computador for de versão diferente.
Então com isso nós podemos ter programas diferentes rodando versões diferentes de Gol ao mesmo tempo.
Por exemplo, esse exemplo, eu tenho esse só simplificado.
Tem um certo serviço, um API rodando, API.Gol na versão Gol 1.36.5.
E ao mesmo tempo na mesma máquina eu tenho o outro serviço aqui.
Rodando no Gol versão 1.17.3.
Então cada um desses executáveis, o executável da API vai ter a sua própria versão Gol rodando lá 1.16.5.
E o serviço vai ter os arquivos da versão Gol compilado na 1.17.3.
E eles não vão interferir entre si.
Então agora eu quero falar de mais uma prática de como você pode faixar uma versão de Gol mais nova e ver se não tem nenhum problema ao compilar o seu programa na versão mais nova.
Então eu vou aqui no meu terminal, eu tenho aqui a versão, eu tenho a versão instalada de Gol 1.16.5 usando o Ubuntu Linux.
E eu quero já rodar na versão, quero ver se o meu programa vai funcionar e não vai quebrar na versão mais nova de Gol.
Vamos fazer isso.
A gente deixa eu te mostrar aqui no navegador que a versão mais nova quando eu gravei esse vídeo é 1.17.3.
Então já tem a versão mais nova.
Então eu pego esse número aqui da parte do Gol1.org-delle.
Eu vou pegar o número da versão mais nova e vou instalar essa versão mais nova aqui.
Eu vou falar Gol Install.
Um detalhe aqui, essa versão mais nova não vai sobre escrever o apagar a versão que já tem, vai ser uma versão adicional.
Então a gente vai ter múltiplas versões na mesma marca.
Vou falar Gol Espaço de Install, Espaço.
Aí eu vou dizer Gol1.org-delle-gol e o número da versão.
1.17.3 como foi especificado lá no site, vou falar Arroba, Lei, Test.
E ele vai baixar um arquivo.
Esse arquivo vai estar no seu GolPath-bin que é o Golbin.
Está aqui Gol1.17.3 e eu posso executá-lo como já está no meu path.
Eu posso falar Gol1.17.3, passo, o argumento vai ser download.
Ele vai baixar.
Vai extrair para, no meu caso, ele instalou essa nova versão na minha pasta pessoal,
Barra Home, Barra NVK, Instructor, Barra SDK, Barra Gol1.17.3.
E você dá o... Agora como você pode dizer Gol1.17.3 e ele vai achar?
Vou falar isso, ele vai achar e vai ter a versão aqui.
Então é assim como você usa a versão diferente da que já estava instalada.
Você só dizer Gol seguido do número da versão.
Gol1.17.3.
Para eu ver, eu já sei que está instalada, acabamos de ver que está instalada na pasta SDK, na minha pasta pessoal.
Eu posso dizer se eu não souber mais, esquecer, Gol1.17.3, passo, and,
espaço, Gol, root, tudo em letras maiúsculos.
Ele te mostra onde está instalada essa versão nova.
Aí você pode fazer o seguinte, antes disso eu vou te mostrar Gol and Gol Roots para a minha versão que já tinha.
Ele está em barra USR e barra local para Gol.
Para vamos continuar.
Então, eu tenho a versão mais nova instalada, a versão adicional, não vai afetar a minha versão que eu já tinha.
E eu vou compilar o meu programa usando essa nova versão e vou rodar o programa e ver se não quebrou nada.
Teoreticamente, sem eu fazer...
Eu não tenho esse arquivo API nesse serviço aqui, do exemplo.
Seria assim, eu faria Gol1.17.3 e faria toda a build e tal, e tal, e tal, e tal.
Eu estou simplificando só para um arquivo, mas seria vários.
Tudo que eu queria mudar, tudo que você faz normalmente com o seu projeto,
é só mudar de Gol para Gol1.17.3, no meu caso, Gol seguido do número da versão.
É só mudar que ele vai usar essa versão mais nova.
E você faz sua build e tal, e tal, e tal, e tal.
Depois disso, você roda o programa e vê se não quebrou nada.
E quebrou e você vai ter que ajustar as coisas.
Mas se não quebrou, você está preparado para usar essa nova build com a nova versão e você pode já começar a usar.
Agora, depois disso, se você quiser substituir a versão padrão que está instalada no seu sistema,
aí é outra coisa, você pode primeiro deletar essa versão que você acabou de instalar.
É só deletar a parte da home, da sua parte pessoal, a barra SDK, a barra do número da versão,
a sua barra R&M, no caso do Linux, passa o R&F e você copia essa pasta.
Ou no seu caso, você pode botar o dólar com Gol1.17.3 e GolRoot.
Ele pode rodar o comando e te dar esse path, e esse path se substituiu daqui e ele remove.
Os doares de Windows vão usar o Dell.
Então, depois disso, você é só ir instalar da mesma maneira que você fez na primeira vez que instalou.
No caso do Windows, vai no site, faça o MSI, instala por cima do que já tinha,
ele vai remover a versão anterior e vai instalar a nova.
Se você confirmou que não quebrou nada com a nova versão, depois de fazer aquele negócio que ele lance do install e do download.
No caso do Mac, pode usar o PKG ou atualiza no brew.
No caso do Linux, baixe de novo o TGZ e substitui o SR local, se você usar lá.
Ou atualiza no seu generador de pacotes no botu apt, mas normalmente é muito, versão muito antiga, então, acho que você nem vai usar.
Então, por isso é só, tá bom pessoal?
É isso mesmo.
Da tarde de novo que eu usei a versão 11.5, para essa demonstração.
As ferramentas, os comandos de desenvolvimento sempre ficam mudando.
Talvez até se você tinha usado a versão anterior, talvez seria outro comando diferente, o GoGate ou alguma coisa assim.
Então, o negócio fica mudando direto, então, fique esperto no lance dos comandos de Go, que às vezes eles mudam mesmo os comandos, o comportamento dos comandos.
Tá bom?
Por essa aula é só e até a próxima.


0020-09 Versões Diferentes de Golang na Mesma Máquina e Preparação para Upgrade

Aprenda sobre o ambiente de desenvolvimento da linguagem Golang. Dicas de instalação e uso de ferramentas para o desenvolvimento em Go. Tópicos como formatação de código, análise de código, etc. Siga o padrão de programação da linguagem Go, na maneira Golang que os arquitetos da linguagem decidiram.


Como Mudar o Valor de Variaveis no Debug de Golang no Visual Studio Code e Comando dlv

```markdown
# Resumo do Transcript sobre Depuração em Go

Antônio discutiu a possibilidade de alterar o conteúdo de variáveis durante a depuração em Go, comparando com o Java. Ele demonstrou como realizar essa tarefa no Visual Studio Code e através da linha de comando usando o DLV (Go Debugger).

## Demonstração no Visual Studio Code

1. **Configuração Inicial:**
   - O arquivo `main.go` é utilizado, contendo uma variável global chamada `nome` que é atribuída a partir de uma função.
   
2. **Adicionando um Breakpoint:**
   - Um breakpoint é configurado na linha 13 para parar a execução do código.
   
3. **Mudando o Valor da Variável:**
   - No painel de variáveis, é possível clicar com o botão direito na variável `nome` e usar a opção "Set Value" (atalho F2).
   - O valor da variável `nome` é alterado para `bob`, e ao continuar a execução, o programa imprime `bob` em vez de `Anna`.

4. **Uso do Debug Console:**
   - O console de depuração permite modificar variáveis diretamente através de comandos feitos na linha de comando, como `nome = "abc"`.

5. **Chamada de Funções:**
   - Para chamar uma função a partir do console, o formato é `call nome_da_função()`.

## Demonstração na Linha de Comando com DLV

1. **Iniciando o DLV:**
   - O comando `dlv debug main.go` inicia a depuração do arquivo.
   
2. **Adicionando um Breakpoint:**
   - O usuário define um breakpoint manualmente com `break main.go:13`.

3. **Continuando a Execução:**
   - O comando `continue` faz o programa avançar até o breakpoint definido.
   
4. **Visualizando Variáveis:**
   - O comando `locals` lista as variáveis locais, enquanto `vars` mostra todas as variáveis, incluindo globais.

5. **Alterando Variáveis:**
   - Para alterar o valor, utiliza-se o comando `call nome = "bove"`.

6. **Executando Comandos:**
   - Próximos comandos podem ser executados usando `next`, que avança a execução passo a passo.
   - Funções podem ser chamadas da mesma forma que no console do Visual Studio Code.

7. **Finalizando a Sessão:**
   - A sessão do DLV pode ser encerrada com o comando `exit`.

Antônio finalizou a demonstração agradecendo e dizendo até a próxima.
```

Antônio perguntou, aproveitando no Java, no debug conseguimos mudar o conteúdo da variável, no Go é possível trocar o conteúdo da variável? Sim.
Então vamos mostrar como fazer isso no VG Studio Code com a instrução do Go.
Também vamos mostrar como fazer isso no linhado de comando do DLV.
Vamos lá então.
Usando o VG Studio, primeiro maneira, como tem o seu arquivo launch, tem a configuração aqui, no meu arquivo tem um arquivo main.go, tem uma atribuição de variável chamada de uma função e tal, variável de tipo global aqui.
Vou debugar, esqueci de colocar um breakpoint, então eu preciso ir na linha 13, cliquei aqui para criar esse breakpoint, aperto play, ele vai parar na linha 13.
No lado esquerdo da tela tem a sessão de variables, variáveis e as variáveis locais, locals.
Nesse caso temos a Anna, que está, essa string atribuída a variável nome.
Para poder mudar o valor, você pode clicar no botão direito aqui e clicar set value, cujo hotkey é f2.
E você pode mudar para outro valor, nesse caso, por exemplo, bog.
E quando continuar a rodar o programa, se clicar continue, ele vai para o próximo breakpoint.
Como não tem mais breakpoint, vai rodar o programa até o final.
Vou abrir o debug console aqui, só apertar controle e cinto grave.
Controle, cliquei debug console, eu vejo aqui que primeiro falou hello world, depois bob, não falou Anna, não acho que liga 14.
Deveria falar Anna, mas como eu vou dar o valor da variável, apareceu bob.
Vamos rodar de novo, vai bater na linha 13.
Também dá para modificar pelo debug console, se você quiser digitar o nome para saber qual é o valor.
Vamos falar qual é o nome igual a abc, ele muda.
O que louco isso aqui apareceu a abc, você diz nome de novo, mudou.
Para mudar, você fala qual o espaço, nome da variável, espaço igual, espaço.
Não precisa de espaço, mas aqui vai ser certo.
E o valor.
Para chamar a função call, espaço, nome da função, parênteses e o argumento, não tem nenhum nesse.
Esse caso retorna o rei.
Acho que tem um detalhe, se a função, você nunca chamar a função do seu código, eu acho que isso não vai funcionar.
Já tentei antes, quando eu não chamava o hello na linha 16, se eu remover essa linha, ele não vai funcionar.
Então, as funções devem ser usadas pelo menos uma vez no seu código para poder funcionar aqui no debug console.
Certo, vou fechar terminar, vou mostrar agora como fazer na linha de comando, mais na mão mesmo.
Vou abrir um terminal, no meu caso aqui, eu vou falar dlv, que é o comando, debug.
E se você tiver um pacote já definido, pode falar dlv debug, mas quando eu não tenho, eu só tenho um arquivo main.go, não tenho um gomode, essas coisas.
Vou dizer main.go.
Eu tenho que estabelecer pelo menos um breakpoint aqui, e vou falar break para adicionar o breakpoint, espaço.
O nome do arquivo vai ser main.go, dois pontos e a linha, neste caso a linha 13, para simular o que eu fiz no video studio code.
Note que, embora eu tenha esse breakpoint no video studio code aqui, ele não vai ser integrado ao comando que eu rodo aqui.
Uma coisa separada, então eu tenho que definir novamente, adicionar o breakpoint na mão mesmo.
O nome do arquivo, main.go, o caminho, dois pontos e a linha 13.
Aí depois eu direto continue para ele continuar o programa até bater no breakpoint.
E ele vai te mostrar aqui que está no breakpoint na linha 13.
Se quiser ver as variáveis locais, direto locals.
Se quiser ver todas as variáveis vars, varrs, note que no final tem a variável de escopo global de lb que eu criei aqui, que é fora das funções, e aparece no chamado vars.
Mas tem muita variável, então é meio que muita coisa.
Então para chamar, mudar o valor da variável, mesmo coisa que eu fiz lá no debug console, onde a gente rodou pelo video studio code mesmo.
Call, nome, igual, por exemplo, bove.
E se eu visitar next para ir para o próximo comando, em vez do próximo breakpoint, note que ele deu print do hello world aqui.
Se eu falar next de novo para executar a linha 14, ele vai dizer bove em vez de anna, porque eu tinha modificado o valor da variável.
Se eu quiser chamar a função call, hello, abre parênteses e usa argumentos, como não tem nenhum, é vazio.
Você note que o valor retornado aparece aqui, values return, hey, que é o valor string que eu retornei na linha 8 aqui do meu arquivo may.go.
Para continuar até o outro breakpoint, como não tem mais, vai continuar até o final e executar um, dois, três, que é o gllb, hey, que vem do hello, e terminou.
Se eu quiser sair, é só exit. Então é por isso mesmo.
Obrigado por assistir, até a próxima. Tchau.
