From 3fbb3deea48aad7b521322e6b722e6138bde46c2 Mon Sep 17 00:00:00 2001 From: fabriciocarraro Date: Thu, 11 Apr 2024 20:00:59 +0200 Subject: [PATCH] Reapply "Tech guide go" (#256) This reverts commit 58006e8c9fbb6f4221ad5ee7f8a184c36922bca3. --- _data/cards/pt_BR/go-concurrency.yaml | 13 +++ _data/cards/pt_BR/go-debugging.yaml | 13 +++ _data/cards/pt_BR/go-errors.yaml | 15 ++++ _data/cards/pt_BR/go-grpc.yaml | 20 +++++ _data/cards/pt_BR/go-interfaces.yaml | 19 +++++ _data/cards/pt_BR/go-oop.yaml | 19 +++++ _data/cards/pt_BR/go-packages.yaml | 19 +++++ .../pt_BR/go-performance-optimization.yaml | 16 ++++ _data/cards/pt_BR/go-persistence.yaml | 19 +++++ _data/cards/pt_BR/go-pointers.yaml | 19 +++++ _data/cards/pt_BR/go-rest-api.yaml | 22 +++++ .../cards/pt_BR/go-routines-and-channels.yaml | 20 +++++ .../pt_BR/go-security-best-practices.yaml | 19 +++++ _data/cards/pt_BR/go-structs.yaml | 19 +++++ _data/cards/pt_BR/go-testing.yaml | 22 +++++ _data/cards/pt_BR/go-web-programming.yaml | 16 ++++ _data/guides/pt_BR/go.yaml | 83 +++++++++++++++++++ 17 files changed, 373 insertions(+) create mode 100644 _data/cards/pt_BR/go-concurrency.yaml create mode 100644 _data/cards/pt_BR/go-debugging.yaml create mode 100644 _data/cards/pt_BR/go-errors.yaml create mode 100644 _data/cards/pt_BR/go-grpc.yaml create mode 100644 _data/cards/pt_BR/go-interfaces.yaml create mode 100644 _data/cards/pt_BR/go-oop.yaml create mode 100644 _data/cards/pt_BR/go-packages.yaml create mode 100644 _data/cards/pt_BR/go-performance-optimization.yaml create mode 100644 _data/cards/pt_BR/go-persistence.yaml create mode 100644 _data/cards/pt_BR/go-pointers.yaml create mode 100644 _data/cards/pt_BR/go-rest-api.yaml create mode 100644 _data/cards/pt_BR/go-routines-and-channels.yaml create mode 100644 _data/cards/pt_BR/go-security-best-practices.yaml create mode 100644 _data/cards/pt_BR/go-structs.yaml create mode 100644 _data/cards/pt_BR/go-testing.yaml create mode 100644 _data/cards/pt_BR/go-web-programming.yaml create mode 100644 _data/guides/pt_BR/go.yaml diff --git a/_data/cards/pt_BR/go-concurrency.yaml b/_data/cards/pt_BR/go-concurrency.yaml new file mode 100644 index 000000000..347cba59c --- /dev/null +++ b/_data/cards/pt_BR/go-concurrency.yaml @@ -0,0 +1,13 @@ +name: Go - Concorrência +logo: +short-description: A concorrência é um dos principais recursos da linguagem Go, permitindo a execução de múltiplas tarefas em paralelo de forma eficiente e simplificada. Utilizando goroutines, uma abstração leve de threads, juntamente com canais para comunicação segura, Go possibilita a construção de aplicações altamente responsivas e escaláveis. Esse modelo de concorrência torna mais fácil escrever programas que tiram pleno proveito de sistemas multicore, ideal para servidores web, processamento em tempo real e outras aplicações que demandam alto desempenho. +key-objectives: + - Entender o modelo de concorrência em Go e como ele difere de outros modelos de programação paralela. + - Aprender a criar e gerenciar goroutines para tarefas concorrentes. + - Utilizar canais para a comunicação segura entre goroutines. +aditional-objectives: +contents: + - type: ARTICLE + title: "Concurrency in Go - Goroutines (inglês)" + link: https://go.dev/tour/concurrency/1 +alura-contents: diff --git a/_data/cards/pt_BR/go-debugging.yaml b/_data/cards/pt_BR/go-debugging.yaml new file mode 100644 index 000000000..d1b0c56ec --- /dev/null +++ b/_data/cards/pt_BR/go-debugging.yaml @@ -0,0 +1,13 @@ +name: Go - Debugging +logo: +short-description: Go oferece ferramentas poderosas e flexíveis para debugging, ajudando desenvolvedores a identificar e corrigir bugs de forma eficiente. Com recursos como o Delve debugger e integração com ambientes de desenvolvimento, Go suporta uma experiência de depuração de alta qualidade que acelera o desenvolvimento de aplicações confiáveis e de alta performance, desde sistemas simples até soluções empresariais complexas. +key-objectives: + - Aprender a utilizar as ferramentas de debugging disponíveis para Go. + - Compreender técnicas eficazes para identificar e resolver bugs em Go. + - Explorar melhores práticas para prevenir erros comuns em desenvolvimento Go. +aditional-objectives: +contents: + - type: ARTICLE + title: "How To Debug Go Code with Visual Studio Code" + link: https://www.digitalocean.com/community/tutorials/debugging-go-code-with-visual-studio-code +alura-contents: diff --git a/_data/cards/pt_BR/go-errors.yaml b/_data/cards/pt_BR/go-errors.yaml new file mode 100644 index 000000000..aa278e3d4 --- /dev/null +++ b/_data/cards/pt_BR/go-errors.yaml @@ -0,0 +1,15 @@ +name: Go - Tratamento de Erros +logo: +short-description: Go aborda o tratamento de erros de maneira explícita, promovendo código claro e previsível. Em vez de exceções, Go utiliza valores de retorno múltiplos para indicar erros, incentivando os desenvolvedores a tratar erros de forma consciente e sistemática. Esse modelo ajuda a construir aplicações robustas, pois encoraja a verificação e o manejo de erros em pontos críticos da execução do programa. +key-objectives: + - Compreender como Go trata erros através de seus mecanismos integrados. + - Aprender a utilizar o tipo `error` para reportar e tratar falhas. + - Explorar padrões de tratamento de erro para manter o código limpo e eficiente. +aditional-objectives: +contents: + - type: ARTICLE + title: "Errors (inglês)" + link: https://pkg.go.dev/errors + - type: ARTICLE + title: "Go por Exemplo: Erros" + link: https://goporexemplo.golangbr.org/errors.html diff --git a/_data/cards/pt_BR/go-grpc.yaml b/_data/cards/pt_BR/go-grpc.yaml new file mode 100644 index 000000000..264acad3b --- /dev/null +++ b/_data/cards/pt_BR/go-grpc.yaml @@ -0,0 +1,20 @@ +name: Go - gRPC +logo: +short-description: GRPC é uma tecnologia moderna para chamadas de procedimento remoto (RPC) que oferece eficiência, baixa latência e suporte a múltiplos idiomas de programação. Go, com sua performance nativa e simplicidade, se torna uma linguagem ideal para implementar e consumir APIs gRPC, facilitando a criação de microserviços altamente eficientes e interoperáveis. Este tópico é essencial para desenvolvedores que buscam construir sistemas distribuídos escaláveis e comunicações entre serviços em arquiteturas de microserviços. +key-objectives: + - Compreender os fundamentos e a arquitetura do gRPC e como ele se integra ao ecossistema Go. + - Aprender a definir serviços gRPC usando protocol buffers, facilitando a interoperabilidade e a eficiência na comunicação entre serviços. + - Desenvolver servidores e clientes gRPC em Go, explorando recursos avançados como streaming, autenticação e interceptores. + - Adotar melhores práticas para o desenvolvimento de APIs gRPC em Go, garantindo segurança, performance e escalabilidade. +aditional-objectives: +contents: + - type: ARTICLE + title: "GRPC (inglês)" + link: https://pkg.go.dev/google.golang.org/grpc + - type: ARTICLE + title: "Escrevendo um micro serviço gRPC em Go: estrutura, definição e deploy no Google Kubernetes Engine" + link: https://medium.com/unicoidtech/escrevendo-um-micro-servi%C3%A7o-grpc-em-go-estrutura-defini%C3%A7%C3%A3o-e-deploy-no-google-kubernetes-engine-82351e23a2f7 +alura-contents: + - type: PODCAST + title: "Hipsters On The Road #54: Go, gRPC e investimentos na Guru" + link: https://cursos.alura.com.br/extra/hipsterstech/go-grpc-e-investimentos-na-guru-hipsters-on-the-road-54-a828 diff --git a/_data/cards/pt_BR/go-interfaces.yaml b/_data/cards/pt_BR/go-interfaces.yaml new file mode 100644 index 000000000..8ec70324f --- /dev/null +++ b/_data/cards/pt_BR/go-interfaces.yaml @@ -0,0 +1,19 @@ +name: Go - Interfaces +logo: +short-description: Interfaces em Go proporcionam uma maneira poderosa e flexível de definir contratos dentro de seus códigos, permitindo a abstração e a polimorfia sem a complexidade encontrada em outras linguagens orientadas a objetos. Elas são um pilar para o design de software em Go, facilitando a desconexão e a interoperabilidade entre diferentes partes de um sistema, tornando o código mais modular, testável e fácil de manter. +key-objectives: + - Compreender o papel das interfaces em Go e como elas contribuem para o polimorfismo. + - Aprender a definir e implementar interfaces, facilitando a interação entre diferentes tipos. + - Explorar o uso de interfaces para desacoplamento e testabilidade do código. +aditional-objectives: +contents: + - type: ARTICLE + title: "Como usar interfaces em Go" + link: https://www.digitalocean.com/community/tutorials/how-to-use-interfaces-in-go-pt + - type: ARTICLE + title: "Interfaces (inglês)" + link: https://go.dev/tour/methods/9 +alura-contents: + - type: COURSE + title: "Curso Go: Orientação a Objetos" + link: https://cursos.alura.com.br/course/go-lang-oo diff --git a/_data/cards/pt_BR/go-oop.yaml b/_data/cards/pt_BR/go-oop.yaml new file mode 100644 index 000000000..2f45869b2 --- /dev/null +++ b/_data/cards/pt_BR/go-oop.yaml @@ -0,0 +1,19 @@ +name: Go - Orientação a Objetos +logo: +short-description: Em Go, métodos são funções associadas a tipos específicos, permitindo uma forma de programação orientada a objetos. Isso facilita a modelagem de conceitos e comportamentos relacionados aos dados, promovendo encapsulamento e reutilização de código. A capacidade de definir métodos sobre tipos permite aos desenvolvedores construir abstrações limpas e manter o código organizado e fácil de manter. +key-objectives: + - Entender como métodos são definidos e associados a tipos em Go. + - Aprender a diferenciar métodos e funções dentro do contexto de Go. + - Explorar a aplicação prática de métodos para manipulação de estruturas e interfaces. +aditional-objectives: +contents: + - type: ARTICLE + title: "Go Methods (inglês)" + link: https://go.dev/tour/methods/1 + - type: ARTICLE + title: "Methods in Golang (inglês)" + link: https://www.geeksforgeeks.org/methods-in-golang/ +alura-contents: + - type: COURSE + title: "Go: Orientação a Objetos" + link: https://cursos.alura.com.br/course/go-lang-oo diff --git a/_data/cards/pt_BR/go-packages.yaml b/_data/cards/pt_BR/go-packages.yaml new file mode 100644 index 000000000..f25b5f1b7 --- /dev/null +++ b/_data/cards/pt_BR/go-packages.yaml @@ -0,0 +1,19 @@ +name: Go - Pacotes +logo: +short-description: O sistema de pacotes em Go facilita a organização, o compartilhamento e a reutilização de código. Com uma estrutura de workspace clara e um gerenciador de dependências integrado, Go promove a criação de aplicações modulares e a colaboração entre desenvolvedores. Este sistema ajuda a manter o código limpo e bem organizado, simplificando a gestão de grandes bases de código e incentivando práticas de desenvolvimento que aumentam a produtividade e melhoram a qualidade do software. +key-objectives: + - Compreender a estrutura e o propósito dos pacotes em Go. + - Aprender a criar, importar e exportar pacotes para modularizar o código. + - Explorar o gerenciamento de dependências utilizando o Go Modules. +aditional-objectives: +contents: + - type: ARTICLE + title: "Packages (inglês)" + link: https://pkg.go.dev/golang.org/x/tools/go/packages + - type: ARTICLE + title: How To Write Packages in Go(inglês)" + link: https://www.digitalocean.com/community/tutorials/how-to-write-packages-in-go +alura-contents: + - type: COURSE + title: "Curso Go: Orientação a Objetos" + link: https://cursos.alura.com.br/course/go-lang-oo diff --git a/_data/cards/pt_BR/go-performance-optimization.yaml b/_data/cards/pt_BR/go-performance-optimization.yaml new file mode 100644 index 000000000..06c6f0e8f --- /dev/null +++ b/_data/cards/pt_BR/go-performance-optimization.yaml @@ -0,0 +1,16 @@ +name: Go - Otimização de Performance +logo: +short-description: Go é conhecida por sua alta performance e eficiência, com recursos avançados para otimização de código. A linguagem permite a criação de aplicações extremamente rápidas e com uso eficiente de recursos, ideal para cenários que exigem alto desempenho, como serviços de alta demanda, processamento de grandes volumes de dados e aplicações críticas para o negócio que operam em ambientes de computação intensiva. +key-objectives: + - Aprender a medir e analisar a performance de aplicações Go. + - Identificar gargalos de performance e aplicar técnicas de otimização. + - Explorar ferramentas e práticas para escrever código Go de alta performance. +aditional-objectives: +contents: + - type: ARTICLE + title: "Performance (inglês)" + link: https://go.dev/wiki/Performance + - type: ARTICLE + title: "Ultimate Golang Performance Optimization (inglês)" + link: https://medium.com/@santoshcitpl/ultimate-golang-performance-optimization-guide-connect-infosoft-9c4c2b75b9f2 + diff --git a/_data/cards/pt_BR/go-persistence.yaml b/_data/cards/pt_BR/go-persistence.yaml new file mode 100644 index 000000000..04dfcf4f5 --- /dev/null +++ b/_data/cards/pt_BR/go-persistence.yaml @@ -0,0 +1,19 @@ +name: Go - Persistência de Dados +logo: +short-description: Go oferece uma abordagem robusta e flexível para a persistência de dados, permitindo a integração com uma ampla gama de sistemas de bancos de dados. Como uma linguagem moderna, Go facilita o desenvolvimento de aplicações de alta performance que requerem operações de banco de dados eficientes, seja através de SQL ou soluções NoSQL. É ideal para desenvolver aplicações web, serviços em nuvem e sistemas distribuídos que necessitam de uma persistência de dados confiável, segura e escalável. +key-objectives: + - Aprender os fundamentos da persistência de dados em Go. + - Explorar a integração de Go com bancos de dados SQL e NoSQL. + - Entender melhores práticas para modelagem e acesso a dados em aplicações Go. +aditional-objectives: +contents: + - type: ARTICLE + title: "Persistence (inglês)" + link: https://pkg.go.dev/github.com/keep-network/keep-common/pkg/persistence + - type: ARTICLE + title: "Simple (And Easy) Data Persistence in Go" + link: https://medium.com/@shanev/simple-and-easy-data-persistence-in-go-aa019a6f3106 +alura-contents: + - type: COURSE + title: "Curso Go: crie uma aplicação web" + link: https://cursos.alura.com.br/course/go-lang-web diff --git a/_data/cards/pt_BR/go-pointers.yaml b/_data/cards/pt_BR/go-pointers.yaml new file mode 100644 index 000000000..fbd425d75 --- /dev/null +++ b/_data/cards/pt_BR/go-pointers.yaml @@ -0,0 +1,19 @@ +name: Go - Ponteiros +logo: +short-description: Os ponteiros em Go são uma ferramenta poderosa, permitindo aos programadores manipular diretamente a memória e referenciar variáveis. Eles são essenciais para a criação de programas eficientes, permitindo passagens de referências a dados sem a necessidade de cópia, otimizando o uso de recursos e a performance. Go simplifica o trabalho com ponteiros, mantendo a segurança do tipo, o que facilita a construção de programas complexos e eficientes sem os perigos comuns associados à aritmética de ponteiros em outras linguagens. +key-objectives: + - Entender o conceito de ponteiros e sua sintaxe em Go. + - Aprender a usar ponteiros para manipulação direta de memória e passagem por referência. + - Explorar técnicas avançadas de ponteiros, incluindo ponteiros para estruturas. +aditional-objectives: +contents: + - type: ARTICLE + title: "Pointers in Go (inglês)" + link: https://go.dev/tour/moretypes/1 + - type: ARTICLE + title: "A Comprehensive Guide to Pointers in Go" + link: https://medium.com/@jamal.kaksouri/a-comprehensive-guide-to-pointers-in-go-4acc58eb1f4d + - type: ARTICLE + title: "Pointers in Golang" + link: https://www.geeksforgeeks.org/pointers-in-golang/ +alura-contents: diff --git a/_data/cards/pt_BR/go-rest-api.yaml b/_data/cards/pt_BR/go-rest-api.yaml new file mode 100644 index 000000000..3ecfee723 --- /dev/null +++ b/_data/cards/pt_BR/go-rest-api.yaml @@ -0,0 +1,22 @@ +name: Go - Construindo APIs REST +logo: +short-description: Go é uma linguagem excelente para construir APIs RESTful devido à sua eficiência, simplicidade e suporte integrado para trabalhar com JSON e comunicações HTTP. Go facilita a criação de APIs web que são ao mesmo tempo escaláveis e de fácil manutenção, tornando-a uma escolha ideal para desenvolvedores que buscam construir interfaces backend robustas para aplicações web e móveis modernas. +key-objectives: + - Compreender os princípios básicos de APIs RESTful e sua implementação em Go. + - Aprender a estruturar uma aplicação Go para suportar o desenvolvimento de APIs. + - Explorar ferramentas e bibliotecas úteis para facilitar o desenvolvimento de APIs em Go. +aditional-objectives: +contents: + - type: ARTICLE + title: "Tutorial: Developing a RESTful API with Go and Gin(inglês)" + link: https://go.dev/doc/tutorial/web-service-gin + - type: ARTICLE + title: "Criando uma API REST em Go (Golang) com Erro Personalizado" + link: https://iamwilliamkoller.medium.com/criando-uma-api-rest-em-go-golang-com-erro-personalizado-668db4967f37 +alura-contents: + - type: COURSE + title: "Curso Go: Desenvolvendo uma API REST" + link: https://cursos.alura.com.br/course/go-desenvolvendo-api-rest + - type: COURSE + title: "Curso Go e Gin: criando API rest com simplicidade" + link: https://cursos.alura.com.br/course/go-gin-api-rest-simplicidade diff --git a/_data/cards/pt_BR/go-routines-and-channels.yaml b/_data/cards/pt_BR/go-routines-and-channels.yaml new file mode 100644 index 000000000..551c3a436 --- /dev/null +++ b/_data/cards/pt_BR/go-routines-and-channels.yaml @@ -0,0 +1,20 @@ +name: Go - Goroutines e Canais +logo: +short-description: Go é reconhecida por sua abordagem inovadora à concorrência, utilizando goroutines e canais. Esses mecanismos permitem o desenvolvimento concorrente com um modelo de programação mais simples e eficiente, facilitando a criação de aplicações capazes de lidar com múltiplas tarefas simultaneamente de forma mais eficaz. Esse modelo é especialmente útil em cenários de alta carga, como serviços web, processamento em tempo real e aplicações de análise de dados. +key-objectives: + - Entender o modelo de concorrência baseado em goroutines e canais em Go. + - Aprender a criar e sincronizar goroutines para tarefas concorrentes. + - Explorar padrões de uso de canais para comunicação segura entre goroutines. +aditional-objectives: +contents: + - type: ARTICLE + title: "Goroutines (inglês)" + link: https://go.dev/tour/concurrency/1 + - type: ARTICLE + title: "Goroutines e go channels" + link: https://medium.com/trainingcenter/goroutines-e-go-channels-f019784d6855 + - type: ARTICLE + title: "Um Pouco Sobre Goroutines em Go!" + link: https://dev.to/jeffotoni/um-pouco-sobre-goroutines-em-go-3lbk +alura-contents: + diff --git a/_data/cards/pt_BR/go-security-best-practices.yaml b/_data/cards/pt_BR/go-security-best-practices.yaml new file mode 100644 index 000000000..d731e795b --- /dev/null +++ b/_data/cards/pt_BR/go-security-best-practices.yaml @@ -0,0 +1,19 @@ +name: Go - Melhores Práticas de Segurança +logo: +short-description: Go proporciona um rico conjunto de ferramentas e bibliotecas para desenvolver aplicações seguras, com suporte a criptografia, autenticação, e proteção contra uma variedade de vulnerabilidades. A linguagem incentiva práticas de desenvolvimento seguro, tornando-a adequada para criar sistemas críticos que exigem altos níveis de segurança, como aplicações financeiras, plataformas de e-commerce e infraestruturas de TI empresariais. +key-objectives: + - Compreender as vulnerabilidades comuns em aplicações Go e como mitigá-las. + - Aprender a implementar técnicas de segurança, como autenticação e criptografia. + - Explorar ferramentas e bibliotecas de segurança disponíveis para Go. +aditional-objectives: +contents: + - type: ARTICLE + title: "Security Best Practices for Go Developers" + link: https://go.dev/doc/security/best-practices + - type: ARTICLE + title: "Security (inglês)" + link: https://go.dev/doc/security/ +alura-contents: + - type: COURSE + title: "Formação Desenvolvimento Seguro" + link: https://cursos.alura.com.br/formacao-desenvolvimento-seguro diff --git a/_data/cards/pt_BR/go-structs.yaml b/_data/cards/pt_BR/go-structs.yaml new file mode 100644 index 000000000..4ce747192 --- /dev/null +++ b/_data/cards/pt_BR/go-structs.yaml @@ -0,0 +1,19 @@ +name: Go - Estruturas +logo: +short-description: Go utiliza structs para agrupar dados relacionados, servindo como a base para modelar entidades e construir aplicações complexas. As structs em Go podem conter dados de diferentes tipos e oferecem a possibilidade de associar métodos a elas, o que facilita a implementação de conceitos orientados a objetos como encapsulamento e herança através de composição, tornando-as ferramentas versáteis para o desenvolvimento de software. +key-objectives: + - Aprender a definir e utilizar estruturas em Go. + - Entender como estruturas podem ser utilizadas para modelar dados e objetos. + - Explorar a relação entre estruturas e métodos para simular a orientação a objetos. +aditional-objectives: +contents: + - type: ARTICLE + title: "Definindo structs no Go" + link: https://www.digitalocean.com/community/tutorials/defining-structs-in-go-pt + - type: ARTICLE + title: "Structs (inglês)" + link: https://go.dev/tour/moretypes/2 +alura-contents: + - type: COURSE + title: "Go: Orientação a Objetos" + link: https://cursos.alura.com.br/course/go-lang-oo diff --git a/_data/cards/pt_BR/go-testing.yaml b/_data/cards/pt_BR/go-testing.yaml new file mode 100644 index 000000000..9f46e69ce --- /dev/null +++ b/_data/cards/pt_BR/go-testing.yaml @@ -0,0 +1,22 @@ +name: Go - Testes +logo: +short-description: Go oferece recursos integrados de teste, tornando fácil escrever e executar testes automatizados para o seu código. Com uma sintaxe simples e ferramentas poderosas, como benchmarks e testes de cobertura, Go encoraja uma cultura de testes contínuos e desenvolvimento guiado por testes (TDD). Esta abordagem assegura a criação de software mais confiável e de alta qualidade, facilitando a detecção precoce de erros e a manutenção do código. +key-objectives: + - Aprender a escrever testes unitários e de integração em Go. + - Entender a importância dos testes para manter a qualidade do código. + - Utilizar ferramentas e frameworks de teste disponíveis na comunidade Go. +aditional-objectives: +contents: + - type: ARTICLE + title: "Go Add a test (inglês)" + link: https://go.dev/doc/tutorial/add-a-test + - type: ARTICLE + title: "Testing in Go (inglês)" + link: https://pkg.go.dev/testing + - type: YOUTUBE + title: "Comprehensive Guide to Testing in Go (inglês)" + link: https://blog.jetbrains.com/go/2022/11/22/comprehensive-guide-to-testing-in-go/ +alura-contents: + - type: COURSE + title: "Curso Go: validações, testes e páginas HTML" + link: https://cursos.alura.com.br/course/go-validacoes-testes-paginas-html diff --git a/_data/cards/pt_BR/go-web-programming.yaml b/_data/cards/pt_BR/go-web-programming.yaml new file mode 100644 index 000000000..e4b39a2d0 --- /dev/null +++ b/_data/cards/pt_BR/go-web-programming.yaml @@ -0,0 +1,16 @@ +name: Go - Programação Web +logo: +short-description: Go é uma escolha popular para o desenvolvimento web devido à sua simplicidade, eficiência e capacidade de lidar com alta concorrência. Com um rico conjunto de bibliotecas padrão e frameworks disponíveis, Go permite aos desenvolvedores construir servidores web rápidos, seguros e escaláveis. É particularmente adequada para criar APIs RESTful, microserviços, e aplicações em tempo real, beneficiando-se da performance nativa e facilidade de manutenção. +key-objectives: + - Aprender a construir servidores web e APIs RESTful com Go. + - Explorar o ecossistema de frameworks e bibliotecas web disponíveis para Go. + - Entender práticas recomendadas para o desenvolvimento web seguro e eficiente com Go. +aditional-objectives: +contents: + - type: ARTICLE + title: "Writing Web Applications (inglês)" + link: https://go.dev/doc/articles/wiki/ +alura-contents: + - type: COURSE + title: "Go: crie uma aplicação web" + link: https://cursos.alura.com.br/course/go-lang-web diff --git a/_data/guides/pt_BR/go.yaml b/_data/guides/pt_BR/go.yaml new file mode 100644 index 000000000..b1673c192 --- /dev/null +++ b/_data/guides/pt_BR/go.yaml @@ -0,0 +1,83 @@ +- name: Go + tags: + - back-end + expertise: + - name: Go Jr + cards: + - go-fundamentals: + priority: 10 + - go-oop: + priority: 9 + - go-structs: + priority: 9 + - go-errors: + priority: 8 + - name: Go Mid + cards: + - go-pointers: + priority: 9 + - go-interfaces: + priority: 8 + - go-concurrency: + priority: 8 + - go-packages: + priority: 8 + - go-testing: + priority: 8 + - go-persistence: + priority: 7 + - go-routines-and-channels: + priority: 9 + - go-web-programming: + priority: 8 + - name: Go Expert + cards: + - go-rest-api: + priority: 9 + - microservices: + priority: 8 + - go-debugging: + priority: 8 + - streaming: + priority: 10 + - go-grpc: + priority: 7 + - go-security-best-practices: + priority: 9 + - go-performance-optimization: + priority: 8 + - collaboration: + - name: DevOps + cards: + - git-and-github-fundamentals: + priority: 9 + - http-fundamentals: + priority: 10 + - ci-cd: + priority: 9 + - virtualization: + priority: 8 + - containerization: + priority: 8 + - name: Best Practices + cards: + - solid: + priority: 8 + - command-line-fundamentals: + priority: 8 + - json: + priority: 6 + - containers: + priority: 7 + - cloud-fundamentals: + priority: 8 + - sql-fundamentals: + priority: 7 + - clean-architecture: + priority: 8 + - design-patterns: + priority: 8 + - ddd-concepts: + priority: 6 + - infrastructure_as_code: + priority: 7