Como eu melhorei minha comunicação e como isso afeta sua vida profissional

Gustavo Nicolau — Mon, 03 Oct 2022 15:17:02 +0000

Esse post é focado um relato de como eu melhorei minha comunicação e quanto isso me ajudou na minha carreira.

Hoje é muito comum pessoas terem uma dificuldade de se comunicar, e pode não parecer mas isso te atrasa e te deixa para trás de pessoas que conseguem se comunicar muito bem.

Eu sempre fui uma pessoa muito mais reservada e até certo ponto da minha carreira eu achei que isso não iria me afetar, mas eu comecei a perceber que eu estava virando alguém que estava ficando para trás e não conseguia acompanhar o ritmo do meu time, quando eu percebi isso eu comecei a me esforçar para melhorar minhas soft skills.

Eu não acho que você vai melhorar sua timidez ou medo de falar com as pessoas em uma ou duas semanas, mas te garanto que em poucos meses você vai perceber uma grande diferença.

Para começar, as vezes você trabalha em um ambiente hostil e isso torna você mais retraído, se você percebe isso eu te aconselho trocar de ambiente. Vamos la, uma das coisas principais que me ajudou foram:

Não pergunte se pode perguntar, apenas pergunte:

Essa sem dúvidas foi uma das coisas que mais me fez conversar com pessoas e me soltar um pouco mais, principalmente em comunidades. Esqueça isso de "será se eu posso perguntar", "puts acho que minha pergunta é idiota", "acho que já perguntaram isso", todas essas questões devem ser irrelevantes, ninguém vai te julgar por uma perguntar, e lembre-se não existe perguntas idiotas.

Expresse sua opinião sempre:

É comum pessoas não falarem suas opiniões com medo de serem julgadas, porém é mega importante você falar sua opinião, isso vai gerar um debate e logo você vai aprender a se comunicar e expressar melhor com mais pessoas, se você tomar uma dura ou algo do tipo por ter falado sua opinião talvez você não devesse estar ali.

Participe de comunidades e fóruns:

Essa também é uma dica muito útil para você melhorar sua comunicação, sem dúvidas você participar de comunidades de coisas que você gosta vai te ajudar e muito a se soltar mais, as vezes você fazer um tweet em alguma comunidade ou interagir por la vai te fazer melhorar muito.

Faça um curso de idiomas:

Outra dica muito importante que me ajudou demais foi o curso de idiomas, eu fiz online porém se você preferir fazer presencial eu garanto que os resultados vão ser ainda melhores. O curso de idiomas vai te fazer perder a timidez muito rápido, falar numa linguagem desconhecida com um desconhecido vai te fazer perder a timidez muito rápido e também melhorar muito sua comunicação

Escreva e pega feedbacks:

Escrever é outra forma muito boa e que agrega em muitos outros pontos da sua vida, você escrever sobre algo que goste vai te ajudar muito a se expressar e também trazer clarezas de como usar as palavras, e claro pedir feedbacks sobre seu artigo vai fazer você se comunicar com muito mais pessoas

Crie um diálogo consigo mesmo:

Essa dica serve para quem realmente é muito tímido e tem muitas dificuldades para começar alguma conversa e até mesmo gagueja, a dica que eu dou é criar um possível dialogo na sua cabeça e ir treinando as respostas, pode ser até mesmo um bom dia, treine um "Oi bom dia, tudo bem?", isso vai te fazer não gaguejar ou tremer quando alguém falar com você e com isso você vai evoluindo

Conclusão

Depois de alguns meses seguindo essas dicas e me esforçando para melhorar minha comunicação eu comecei a ver resultados, meu time começou a falar mais comigo, eu comecei a ficar mais a frente de projetos, comecei a ficar mais por dentro de coisas do meu próprio time, e até cheguei a ser promovido depois com elogios principalmente na minha parte comunicativa onde viram que eu melhorei bastante e isso agregou muito para minha equipe. Então se você tem tanta dificuldade em se comunicar, tente fazer um esforço, a recompensa a longo prazo é enorme.

Introdução ao gRPC - Golang

Gustavo Nicolau — Sat, 18 Jun 2022 21:06:36 +0000

Há algum tempo a arquitetura de API's REST vem dominando o mercado, seja em aplicativos web ou microserviços. Porém existe outras arquiteturas mais modernas e com muito mais vantagens que o REST, hoje nós vamos falar do gRPC

O que é gRPC?

gRPC é um sistema de código aberto criado pela Google em 2015 como uma melhoria para a arquitetura de comunicação chamada RPC ( Remote Procedure Call).

O gRPC usa em seu sistema de mensagens o formato Protobuf (Protocol buffers), que é um forma de definir uma estrutura de dados assim como o JSON e XML só que muito mais rápido e muito mais leve.

Outra grande vantagem de usar o gRPC é que normalmente API's REST são escritas em HTTP/1.1 ao contrário do gRPC que usa HTTP/2

O que é Protobuf?

O Protobuf ou Protocol Buffer como dito anteriormente, é que é um forma de definir uma estrutura de dados assim como o JSON e XML, ele funciona de uma forma um pouco diferente desses dois e tem muitos benefícios sobre eles.

Outra vantagem muito legal do Protobuf é que você pode gerar automaticamente código para várias linguagens, no momento que eu escrevo são elas C++, C#, Dart, Go, Java, Kotlin e Python. Mas para isso precisamos criar um arquivo com a extensão .proto para que isto dê certo,dito isso vamos colocar em prática esses conceitos.

E qual a vantagem de usar HTTP/2?

Além do fato de que o HTTP/2 ser muito mais recente que o HTTP/1.1 as principais vantagens são:

Conexão Única: O HTTP/1.1 é um protocolo sequencial, onde o navegador precisa abrir diversas conexões TCP em sequência para os arquivos e caso um arquivo seja muito pesado o processamento acaba sendo lento, já o HTTP/2 ele precisa de apenas uma conexão TCP onde ele fará todas as requisições necessárias para buscar os arquivos, e isso trás um custo de processamento e memória menor junto com uma latência mais baixa também, trazendo benefícios de hardware e software.

Compactação dos cabeçalhos: Tanto o HTTP/1.1 quanto o HTTP/2 comprimem suas mensagens nas requisições, porém o HTTP/2 usa o HPACK, que é um algoritmo mais avançado que elimina algumas informações repetidas nos cabeçalhos tornando o carregamento de arquivos e pacotes muito mais rápído.
Server Push: Outra vantagem do HTTP/2 é que ele pode ser bidirecional ou seja, tanto o servidor quanto o cliente podem trocar informações entre si sem que seja solicitado, diferentemente do HTTP/1.1 que é necessário fazer uma requisição nova sempre que precisar de um novo conteúdo

Antes de tudo vamos usar a linguagem Go para o desenvolvimento do nosso servidor gRPC, não se apegue a linguagens porque isso não vai ser importante por agora.
Agora vamos iniciar nosso projeto com

go mod init grpc-go

Logo depois vamos criar uma pasta chamada 'contracts' que será onde vamos criar nosso um arquivo chamado hello.proto.
Feito isso vamos criar nossa primeira estrutura de dados, que será um request e um response da nossa aplicação

syntax = "proto3";

message HelloRequest {
    string name = 1;
}

message HelloResponse {
    string msg = 1;
}

Aqui nós criamos duas estruturas de dados, o número seguido do tipo e nome da variável é a ordem que ele vai ficar na estrutura.
Feito isso vamos adicionar também mais duas coisas nesse arquivo


option go_package = "./pb";

service HelloService {
    rpc Hello(HelloRequest) returns (HelloResponse) {};
}

a primeira linha que nós adicionamos é para o gerador de código do protobuf sabe onde ele deve criar os arquivos, que no caso vai ser na pasta pb, já o service HelloService que nós criamos é os serviços que vamos usar no nosso servidor, dentro dele criamos a função Hello e nela recebemos a estrutura de dados de request e vamos retornar a estrutura de response.

Antes de prosseguirmos, vamos instalar o compilador do Protobuf que irá gerar nosso código.

Caso esteja usando Linux, você pode usar o apt ou o apt-get, por exemplo

apt install -y protobuf-compiler
protoc --version

Caso esteja no Mac, você pode usar o Homebrew

brew install protobuf
protoc --version

Caso esteja no Windows ou outro SO, você pode consultar o site oficial para fazer a instalação

Feito isso vamos rodar o comando

protoc --go_out=plugins=grpc:./ contracts/*.proto

Isso vai criar a pasta pb e gerar um novo arquivo .go chamado hello.pb.go e nesse arquivo vamos ter uma série de métodos criados pelo gerador de código automático do protobuf. Vamos também instalar a dependência do gRPC do go, para isso damos esse comando

go get -u google.golang.org/grpc

Agora depois de finalizado a instalação, vamos criar nosso servidor. Primeiro vamos criar uma pasta chamada server e dentro dela um arquivo chamado main.go. Dentro desse arquivo vamos começar com o seguinte

package main

import (
    "context"
    "grpc-go/pb"
    "log"
    "net"

    "google.golang.org/grpc"
)

type Server struct {}

func (s *Server) Hello(ctx context.Context, request *pb.HelloRequest) (*pb.HelloResponse, error) {

}


func main(){

}

Nós criamos uma struct chamada Server e depois criamos um método para essa struct chamado Hello que vai ser nossa primeira função do servidor, e essa função recebe dois parâmetros, o primeiro sendo um context que não nos interessa por agora, e o segundo sendo o HelloRequest que nós tinhamos criado no arquivo hello.proto. Isso tudo é possível graças ao gerador de código do protobuf que criou o módulo pb que contém todas essas informações.
Após isso vamos criar nosso retorno da função fazendo o seguinte

func (s *Server) Hello(ctx context.Context, request *pb.HelloRequest) (*pb.HelloResponse, error) {
    return &pb.HelloResponse{Msg: "Hello " + request.GetName()}, nil
}

Como podem ver nós estamos retornando a estrutura de dados de response, porém temos um request.GetName(), uma função que nós não definimos antes, e isso acontece por que o protobuf ao gerar o código para gente, faz os getters e setters automaticamente, isso ajuda muito no desenvolvimento.
Agora vamos criar iniciar nosso servidor na função main do nosso arquivo

func main(){
    listen, err := net.Listen("tcp", "0.0.0.0:9000")

    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }

    grpcServer := grpc.NewServer()
    pb.RegisterHelloServiceServer(grpcServer, &Server{})

    if err := grpcServer.Serve(listen); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

Na nossa primeira linha da função nós iniciamos nosso servidor na porta 9000 e logo após nós validamos para ver se não deu nada de errado. Após isso iniciamos nosso servidor gRPC e depois nós registramos nosso serviço que foi criado no arquivo hello.proto, nós passamos como parâmetro o servidor gRPC que foi iniciado e depois nossa struct do servidor.
Logo após isso iniciamos o nosso servidor gRPC e verificamos se não vai dar nenhum erro.
Agora vamos rodar nosso servidor com um

go run server/main.go

Bom a parte de servidor está pronta, porém nós precisamos testar para ver tudo funcionando, para isso vamos criar uma nova pasta chamada de client, e dentro dela vamos criar um arquivo main.go. Dentro desse arquivo vamos colocar isso

package main

import (
    "context"
    "grpc-go/pb"
    "log"

    "google.golang.org/grpc"
)

func main(){
    connection, err := grpc.Dial("localhost:9000", grpc.WithInsecure())

    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    defer connection.Close()

    client := pb.NewHelloServiceClient(connection)

    request := &pb.HelloRequest{Name: "Seu nome"}

    response, err := client.Hello(context.Background(), request)

    if err != nil { 
        log.Fatalf("Failed to call: %v", err)
    }

    log.Printf("Response: %v", response.Msg)
}

Nós chamamos a função main e nela começamos criando uma conexão com o gRPC e nessa função de conexão grpc.Dial nós passamos dois parâmetros, o endereço do servidor e também uma função que nada mais é que o tipo de conexão que estamos fazendo, como nós estamos localhost, vamos usar o WithInsecure.
Depois nós verificamos se não existe nenhum erro, logo após isso nós damos um defer connection.Close(), que basicamente vai fechar a nossa conexão antes da função ser encerrada.
Criamos também nossa variável de cliente, onde ele conecta diretamente com o módulo gerado pelo protobuf, e também montamos nosso request puxando também o módulo gerado automaticamente.
Depois chamamos nossa função Hello que está atrelada a nossa variável client e nela nós passamos nossos dois parâmetros necessários, o context.Background() que não nos interessa e também o nosso request que nós criamos acima.
Após isso nós verificamos se não deu nenhum erro durante a chamada da nossa função e então nós mostramos o resultado que o nosso servidor nos enviou. Vamos testar isso dando um

go run client/main.go

Caso o console exiba a mensagem Response: Hello Seu nome foi porque nosso servidor e nosso cliente funcionou perfeitamente.

Conclusão

Mesmo que ainda hoje boa parte da WEB se concentra em arquiteturas REST, usar gRPC para microserviços ou até mesmo aplicações maiores pode ser uma vantagem para você e para seu time, as vantagens que o gRPC trás valem muito a pena para serem usadas no dia a dia principalmente quando o foco é reduzir latências.

DEV Community: Gustavo Nicolau

Como eu melhorei minha comunicação e como isso afeta sua vida profissional

Não pergunte se pode perguntar, apenas pergunte:

Expresse sua opinião sempre:

Participe de comunidades e fóruns:

Faça um curso de idiomas:

Escreva e pega feedbacks:

Crie um diálogo consigo mesmo:

Conclusão

Introdução ao gRPC - Golang

O que é gRPC?

O que é Protobuf?

E qual a vantagem de usar HTTP/2?

Conclusão