Muito bom! Pretendo aprender golang também, mas vejo ela sendo muito forte em IAC principalmente

Muito bom César! Tenho muita vontade de fazer o mesmo, vi alguns códigos em Golang que me chamaram muita atenção, estive no meio da ponte da escolha entre o Rust e o Golang, acabei optando pelo Rust por gostar bastante de como funciona C e C++, mas quero muito estudar Golang no futuro. Já guardei até alguns códigos para praticar, um deles cria PDFs de notas fiscais.

Muito bom! Eu também tenho essa mesma vontade, até já vi um material legal para começar. Existe um canal no YouTube bem interessante, que é o "Aprenda Go". Fica a recomendação. Bons estudos!

Também estou nessa de aprender Go, trabalho com JavaScript e tecnologias ao redor dela (Node, Angular), tenho conhecimentos sobre Java mas é uma linguagem que nunca gostei, e trabalhando em uma empresa que a cultura cloud é muito forte analisei e vi que muitas coisas desse universo são feitas com Golang, tipo Kubernetes entre várias outras. Comecei a pesquisar e depois a estudar sobre e definitivamente é uma linguagem na qual vou me dedicar profundamente. No momento estou fazendo o curso Aprenda Go no youtube, que é muito bom e o que tbm estou gostando são alguns artigos no site da treinaweb.

Eu tambem estou inclinado a estudar Go, estou fugindo do universo Javascript e achei muito legal Go, sua proposta. Só estou em dúvida se aprendo Go vou pro PHP + Laravel, pois ainda estou em busca da minha primeira vaga e não sei como anda o mercado de Go no Brasil

Para incrementar o seu material, dê uma olhada nesses canais no youtube:

em português

• https://www.youtube.com/@aprendago
• https://www.youtube.com/@aprendagolang
  em inglês
• https://www.youtube.com/@ardanlabs6339
• https://www.youtube.com/@codewithryan

Desses canais, os brasileiros são os melhores e o ArdanLabs tem desenvolvimento em blockchain com Go.

Espero que você esteja bem! Incrível saber que cada vez mais gente explorando o mundo do Golang. Eu comecei recentemente e estou simplesmente fascinado com tudo o que essa linguagem pode fazer. Queria te desejar muita sorte nessa jornada emocionante!

Ah, e falando em aprender Golang, descobri que tem sido um verdadeiro impulso para o meu progresso: livros! É um um conselho tradicional, mas acredite em mim, eles realmente fazem a diferença. Atualmente, estou mergulhado em um livro chamado 'A Linguagem de Programação Go'. É simplesmente brilhante! Ele desmistifica conceitos complexos e me ajuda a entender o potencial incrível do Golang.

Esses livros ainda estão com um preço super acessível. Acho que é uma oportunidade que não podemos deixar passar. Tenho uma lista de outros títulos na minha mira que pretendo adquirir em breve.

Se você quiser conferir o livro que estou lendo, dá uma olhada neste link: A Linguagem de programação Go Acredito que você também vai adorar a jornada que essas páginas nos proporcionam.

Boa sorte.

Opa mano, eu fiquei animado ao ver o seu post sobre aprender Golang. Mas vou compartilhar algo bem interessante sobre Rust. Vou te mostrar como Rust pode te ajudar de uma forma um pouco melhor que o Golang (na minha opinião)

Golang é bacana e tudo, mas o tratamento de erros às vezes pode ser um pouco vago. Dá uma olhada nesse código Golang:

package main

import (
	"fmt"
	"errors"
)

func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("Divisão por zero")
	}
	return a / b, nil
}

func main() {
	result, err := divide(10, 0)
	if err != nil {
		fmt.Println("Erro:", err)
		return
	}
	fmt.Println("Resultado:", result)
}

Aqui estamos utilizando um tipo de erro simples. Mas e quando precisamos lidar com erros de tipos diferentes? É aí que Rust se destaca com seu "pattern matching" e os tipos "Result" e "Option".

Dá uma olhada nesse trecho de código em Rust:

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        return Err("Divisão por zero".to_string());
    }
    Ok(a / b)
}

fn main() {
    let result = divide(10.0, 0.0);
    match result {
        Ok(val) => println!("Resultado: {}", val),
        Err(err) => println!("Erro: {}", err),
    }
}

Nesse exemplo, estamos usando "Result" para representar sucesso ou erro, e o "match" para fazer uma correspondência com os resultados. Isso traz uma clareza incrível ao lidar com diferentes cenários de erro.

E quanto ao "Option", ele é bastante útil em situações em que um valor pode ser nulo. Enquanto Golang utiliza o conhecido "nil", em Rust a abordagem é diferente. Olha só esse pedaço:

fn find_element(arr: &[i32], target: i32) -> Option<usize> {
    for (index, &value) in arr.iter().enumerate() {
        if value == target {
            return Some(index);
        }
    }
    None
}

fn main() {
    let arr = [1, 2, 3, 4, 5];
    let target = 3;
    match find_element(&arr, target) {
        Some(index) => println!("Encontrado no índice: {}", index),
        None => println!("Elemento não encontrado"),
    }
}

Nesse caso, estamos utilizando "Option" para expressar a possibilidade de um valor nulo. Isso ajuda a escrever um código que lida explicitamente com essa situação, evitando surpresas desagradáveis.

Eu, particularmente, até gosto do Golang. Acho uma linguagem muito bem feita e bem aquitetada. Mas eu sinceramente recomendo pelo menos dar uma chance ao Rust.

Independentemente da sua escolha, continue na jornada de aprendizado e não hesite em buscar mais informações.

Cara, muito legal sua metodologia. Bem motivadora. Eu também estou iniciando meus estudo em golang. Vou acompanhar seu prpgresso.

Muito bom, otimos estudos , Go é top de mais principalmente no mundo cloud , se uma pessoa se garante nesse assunto fica disputado no mercado. boa sorte amigo!