DEV Community: Vinícius Moraes

Porque você deveria ser tecnicamente o pior desenvolvedor do seu time

Vinícius Moraes — Wed, 09 Dec 2020 04:25:21 +0000

Provavelmente você deve estar se perguntando o porque você deveria escolher ser tecnicamente o pior desenvolvedor do seu time, e se isso seria algo ruim, certo?.

Nesse artigo eu gostaria de compartilhar com você, o meu ponto de vista sobre esse assunto e o porque eu considero isso é extremamente importante.

Escolhendo o time certo 👉

A partir do momento que você é o desenvolvedor com menos conhecimento técnico do seu time, a tendência é que você aprenda muito pelo fato de estar com outras pessoas que tem um conhecimento técnico maior que o seu, por exemplo quando o seu time começar alguma conversa sobre decisões arquiteturais, design de aplicação, frameworks ou linguagens de programação, assim é possível que você tenha acesso a ideias e argumentos que nunca tinha se quer pensado a respeito.

Já é comprovado que o meio no qual convivemos acaba nos influenciando positivamente ou negativamente, se estamos em um time no qual o nível técnico é maior do que conhecemos, podemos melhorar nossas habilidades, apenas levando em conta com quem estamos trabalhando, sendo assim ficar em um time no qual você está estagnado tecnicamente por muito tempo pode impactar diretamente no seu conhecimento.

As pessoas ao seu redor afetam a sua performance, pois então escolha bem o seu time :)

Encontrando um time 🔎

Não necessariamente você precisa mudar de time no seu trabalho ou até mesmo de empresa só porque gostaria de trabalhar com pessoas melhores, você pode encontrar outras situações, algumas ideias de como conseguir se expor a esse tipo de situação:

Encontre um projeto Open Source no qual você gostaria de compartilhar e que os desenvolvedores parecem estar em um nível técnico acima do seu, desenvolvedores estão frequentemente procurando por projetos para ocupar seu tempo livre.
Participe de encontro de grupos presenciais ou online sobre assuntos que você tenha interesse.
Participe de conversas técnicas com desenvolvedores mais experientes do que você, nem que seja apenas para ficar de ouvinte, assim você conseguira ter acesso a argumentos e pontos de vistas diferentes.

Sendo o "pior" do seu grupo 🧑‍💻

Após encontrar um time no qual você pode fazer parte, tenha em mente algumas atitudes que podem te ajudar nesse momento de evolução técnica.

Peça feedbacks constantes sobre o seu trabalho ou colaboração, muitas vezes não conseguimos enxergar quais pontos podemos melhorar, o ponto de vista de outro desenvolvedor pode te ajudar nesse aspecto.
Recomendações de livros e cursos, como desenvolvedor sempre estamos em busca de novos conhecimentos, porque não perguntar quais livros o seu time poderia te indicar?, ou quais cursos eles estão fazendo ultimamente.
Programação em par ou pareamento, quando tiver a oportunidade e se possível procure um desenvolvedor que tenha alguma habilidade técnica que você queira aprender, essa é uma ótima forma de ver como outro desenvolvedor pensa quando está desenvolvendo.

Quando começamos a conviver em um time no qual propõe esse tipo de cenário, começamos a achar que somos inexplicavelmente mais inteligente por estar convivendo com pessoas tecnicamente superiores a nós, você pode até mesmo falar e escrever de forma mais inteligente, seus códigos ficam mais elegantes e você acredita ser capaz de resolver problemas difíceis com soluções cada vez mais criativas.

Muito obrigado por ler esse post, espero que ele tenha te ajudado de alguma forma, e caso tenha ficado com alguma dúvida em relação aos pontos abordados, sinta-se a vontade para deixar um comentário 😄

4 essentials tips for beginners programmers

Vinícius Moraes — Tue, 03 Nov 2020 01:32:30 +0000

🇧🇷 Portuguese version here

In 2020, I complete 7 years as a software developer, in this article I would like to share all important points, that I consider it can help you in your journey.

Don't be a Fullstack Developer 🤷‍♂️

But be a Fullstack developer isn't good? my value as a profissional isn't grow because I know frontend & backend?,
I'm going to explain to you why understand Frontend & Backend could be a bad choose.

In the past web applications was build with Frontend and Backend in the same application, for example a web application using Java for Backend with Spring MvC as web framework and JSP(Java Server Pages) a technology responsible for create web pages using HTML.

Fronted complexity was increasing more and more, with new ways to represent web pages and mobile applications like responsive interfaces, dynamics and others, that is impossible to create interfaces using technologies as JSP mentioned above, this also applies to Backend, which covers a huge range of technologies, practices and patterns in development.

Trying to understand Backend & Frontend at same time,
at least in the beginning of your career it ends up being something complex and totally unviable due to the infinity of technologies and frameworks that you would have to understand.

To represent better all the points mentioned above, I will leave a link to a repository on Github that clearly shows all these points that I mentioned.

It is possible to have a view of all the complexity we currently have for paths such as Frontend, Backend and DevOps.

(The Developer Roadmap)[https://github.com/kamranahmedse/developer-roadmap]

Practice as much as you can 🧑‍💻

Programming is a profession of practice, so more you practice better you will get, when you have free time and if you can, practice, this will help you when you have to develop a new feature or solve a problem in the real world.

Practice constantly will expose you to a lot of situations very similar to what we have in a real world applications.

Solving Bugs
Configuration of application and frameworks
Code design of application

I know in the beginning it can be difficult to think in some projects ideas to develop, so I will leave here some github repositories that can help you start a new project.

Backend Challenges

Frontend Challenges

App Ideias

Don't forget to put all the projects you created practicing on Github, so in addition sharing all your learning, it would also be available for other developers to learn and be inspired by with your project, in addition to making your learning available to recruits.

Don't think about the amount of your salary 💰

Programmer is currently a well-paid profession due to the lack of professionals and the growth of technologies in companies, however, at the beginning of your career, focus as much as you can on learning, if you are in college do your best to get an internship, so that you will get experience and may even become a junior programmer in the future.

I have as a principle that salary is not only the money we receive when we work, but also all the learning we receive together with him.

Stay calm with enough practice, studies and dedication you can be sure that you will get a good remuneration, and the more you dedicate yourself, the greater your value in the market, because currently the market is full of average programmers, average because most only practice in working hours, do not study in free time or at least update herself.

Get a hobby 🏂

But how does this relate to programming?

Have you ever been in a situation where you tried to solve a problem, ended up staying hours and hours and only managed to think of a solution when you stopped to cool your head?

Programming is a creative process and requires a lot of mental effort, so you end up getting tired more quickly due to the effort to understand all the complexity implemented in the code.

An activity that involves passion and naturalness is extremely stimulating for the creative sectors of your mind

Look for something you are happy to do, such as practice sports or playing an instrument.

Thank you very much for reading this post, I hope it has helped you in some way, and if you have any questions, feel free to leave a comment 😄

4 dicas essenciais para programadores iniciantes

Vinícius Moraes — Sun, 11 Oct 2020 19:43:42 +0000

🇬🇧 English version here

No ano de 2020 completo 7 anos como desenvolvedor de software, e nesse artigo gostaria de compartilhar alguns pontos que eu considero importante, e que podem te ajudar nesse começo da sua jornada.

Não seja um Desenvolvedor Fullstack 🤷‍♂️

Mas ser um desenvolvedor fullstack não é algo bom? o meu valor no mercado não irá aumentar por saber tanto o frontend quanto o backend?, vou te explicar porque na minha opinião começar a carreira tentando entender tanto o frontend quanto o backend pode ser uma má escolha.

Antigamente as aplicações web eram feitas com o frontend e o backend na mesma aplicação, por exemplo uma aplicação web utilizando Java para desenvolver o backend com Spring MvC como framework web e JSP (Java Server Pages) uma tecnologia responsável por criar páginas web utilizando HTML.

Com a complexidade do Frontend aumentando cada vez mais, com novas formas de representar páginas web e aplicativos móveis como interfaces responsivas, dinâmicas entre outros, não seria possível criar interfaces dessa forma utilizando tecnologias como JSP citada acima, sendo assim a complexidade para se entender o Frontend é enorme, isso também se aplica ao Backend que abrange uma enorme gama de tecnologias, práticas e padrões no desenvolvimento.

Ao tentar entender backend e frontend ao mesmo tempo, pelo menos no inicio de sua carreira acaba sendo algo complexo e totalmente inviável devido a infinidade de tecnologias e frameworks que você teria que entender.

Para representar melhor todos os pontos que citei acima, vou deixar um link para um repositório no Github que mostra com clareza todos esses pontos que citei.

Nele é possível ter uma visão de toda a complexidade que temos atualmente para os caminhos como Frontend, Backend e DevOps

The Developer Roadmap

Pratique o máximo que puder 🧑‍💻

Programação é uma profissão de prática e quanto mais você praticar melhor irá ficar, quando tiver um tempo livre e se puder pratique, isso irá te ajudar quando você tiver que desenvolver alguma nova funcionalidade ou resolver algum problema no mundo real.

Praticando constantemente irá te expor a situações muito parecidos com o que temos na "vida real", como por exemplo:

Resolução de Bugs
Configurações de projetos e frameworks
Organização e design da sua aplicação

Sei que no começo acaba sendo difícil pensar em ideias de projetos para desenvolver sendo assim vou deixar aqui embaixo alguns links úteis de ideias de projetos :)

Backend Challenges

Frontend Challenges

App Ideias

Não se esqueça de colocar todos os projetos que criou praticando no Github, assim além de armazenar e compartilhar todo o seu aprendizado, ele também ficaria disponível para que outros desenvolvedores possam aprender e se inspirar com o seu projeto, além de deixar disponível o seu aprendizado para os recrutados.

Não pense no valor do seu salário 💰

Programador atualmente é uma profissão bem remunerada devido a falta de profissionais e o crescimento da tecnologias nas empresas, porém no inicio de sua carreira foque o máximo que puder em aprender, se estiver na faculdade faça o possível para conseguir um estágio, pois assim você conseguira experiencia e podendo até se tornar um programador junior no futuro.

Eu tenho como princípio que salário não é apenas o dinheiro que recebemos quando trabalhamos, mas também todo o aprendizado que recebemos junto com ele.

Fique tranquilo com bastante prática, estudos e dedicação pode ter certeza que você irá conseguir uma boa remuneração, e quanto mais você se dedicar, maior será o seu valor no mercado, pois atualmente o mercado está cheio de programadores medianos, mediano pois a maioria apenas prática no horário de trabalho, não estuda no tempo livre ou ao menos se atualiza.

Tenha um hobby 🏂

Mas qual a relação disso com programação?.

Você já passou pela situação na qual tentou solucionar um problema, acabou ficando horas e horas e só conseguiu pensar em uma solução quando parou para esfriar a cabeça?.

Programação é um processo criativo e que exige um esforço mental muito grande, assim você acaba se cansando mais rapidamente devido ao esforço para entender toda a complexidade implementada no código.

Uma atividade que envolva paixão e naturalidade é extremamente estimulante para os setores criativos da sua mente

Procure algo que você tenha prazer em fazer, como praticar esporte ou tocar algum instrumento.

Entrega Contínua: Análise de código, testes, build e deploy automatizado com CircleCI & gradle

Vinícius Moraes — Tue, 29 Sep 2020 12:46:59 +0000

Nos últimos dias, venho estudando sobre entrega contínua, e, durante esse processo acabei criando um pipeline no qual eu vou compartilhar nesse post com vocês :)

Se você ainda não sabe o que é entrega contínua clique aqui

O que será abordado nesse post ?

Análise código(bugs, segurança e vulnerabilidades) utilizando SonarQube
Testes unitários e de Integração rodando em paralelo para otimizar o pipeline
Build do projeto
Deploy automático da aplicação no Heroku
Teste de API após o deploy

A ferramenta que eu estou utilizando como CD(entrega contínua) é o CircleCI, sendo assim, é nela que eu irei mostrar os exemplos.

CircleCI

É uma plataforma de integração e entrega contínua (CICD) para sistemas operacionais como Linux, macOS e Android e etc, totalmente em nuvem.

Talk is cheap, show me the code

Nosso primeiro passo é criar as tasks no gradle para o teste unitário e teste de integração, isso nos ajudara a separar o jobs na execução do pipeline.

O código das tasks ficará assim no arquivo build.gradle.kts:


tasks {
  create("unitTest", Test::class) {
        filter {
            includeTestsMatching("br.com.projeto.core.*")
        }
        testLogging {
            events(TestLogEvent.PASSED)
            events(TestLogEvent.FAILED)
        }
    }

create("integrationTest", Test::class) {
        filter {
            includeTestsMatching("integration.*")
        }
        testLogging {
            events(TestLogEvent.PASSED)
            events(TestLogEvent.FAILED)
        }
    }
}

Basicamente a task unitTest roda todos os testes que estão dentro do pacote `br.com.projeto.core.*`, já a task integrationTest como o próprio nome já diz, executa os testes de integração do pacote `integration.*`, as duas tasks tem como configuração o test logging mostrando os testes que passaram e que falharam.

No meu caso, a estrutura dos pacotes de testes do meu projeto estão assim:

test > kotlin > br.com.projeto.core (testes unitários)
test > kotlin > integration

Certo, agora que temos essas duas tasks, podemos inclui-las no nosso arquivo config.yml do CircleCI que está no projeto:

  unit-test:
    working_directory: ~/
    docker:
      - image: circleci/openjdk:11-jdk-stretch-node-browsers
    steps:
      - checkout
      - run:
          name: Unit tests
          command: ./gradlew unitTest

  integration-test:
    working_directory: ~/
    machine: true
    environment:
      JAVA_HOME: /usr/lib/jvm/java-11-openjdk-amd64
      JAVA_TOOL_OPTIONS: "-Xmx4G"
      GRADLE_OPTS: "-Xmx4G -Dorg.gradle.daemon=false -DdisablePreDex"
    steps:
      - run:
          name: Download Java 11
          command: |
            sudo apt update
            sudo apt install openjdk-11-jdk
      - checkout
      - run:
          name: Integration tests
          command: ./gradlew integrationTest

workflows:
 'Test, Build and Deploy Workflow':
  jobs:
    - unit-test
    - integration-test

Nosso segundo passo, é configurar o SonarQube no projeto, para que o pipeline faça o upload da análise automaticamente no SonarCloud.

SonarQube

É uma ferramente para análise de código, sendo possível analisar qualidade de código, bugs e possíveis falhas de segurança.

Dentro do arquivo build.gradle.kts é necessário inserir o código abaixo:

plugins {
   id("org.sonarqube") version "3.0"
}

sonarqube {
    properties {
        property("sonar.projectKey", "chave do seu projeto")
        property("sonar.organization", "sua organizacao")
        property("sonar.host.url", "https://sonarcloud.io")
    }
}

Feito isso, agora precisamos adicionar o job no pipeline, adicionando no arquivo config.yml:

Não se preocupe com o arquivo config.yml agora, vou deixar ele completo no final do post :D

  code_analysis:
    docker:
      - image: circleci/openjdk:11-jdk-stretch-node-browsers
    steps:
      - checkout
      - run:
          name: Sonarqube analysis
          command: ./gradlew sonarqube

workflows:
 'Test, Build and Deploy Workflow':
  jobs:
    - unit-test
    - integration-test
    - code_analysis:
        requires:
           - unit-test
           - integration-test
        context: sonarqube

Repare que no job de code_analysis foi adicionado a tag requires que indica que esse job só deve ser executado após os jobs unit-test e integration-test terem sido executados com sucesso, a tag (context)[https://circleci.com/docs/2.0/contexts/] indica que o Job deve utilizar o context criado no CircleCI (no caso sonarqube) utilizando as variáveis que foram definidas nesse contexto.

Certo, agora que adicionamos os testes e a análise de código precisamos executar o build do projeto para que seja gerado o pacote para o deploy da aplicação.

Vamos adicionar o job que executa o build:

   build:
    working_directory: ~/
    docker:
      - image: circleci/openjdk:11-jdk-stretch-node-browsers
    steps:
      - checkout
      - restore_cache:
          keys:
            - v1-dependencies-{{ checksum "build.gradle.kts" }}
            - v1-dependencies-
      - run:
          name: Run assemble
          command: ./gradlew clean assemble
      - save_cache:
          paths:
            - ~/.gradle
          key: v1-dependencies-{{ checksum "build.gradle.kts" }}

Agora que conseguimos fazer o build da nossa aplicação de forma automatizada, vamos para a próxima etapa, no caso o deploy.

O CircleCI disponibiliza orbs que de forma resumida, são pacotes open source que reduzem a complexidade de configuração para criar jobs, commands e executors. Vamos utilizar a orb do Heroku para executar o deploy.

version: 2.1

orbs:
  heroku: circleci/heroku@1.2.2
jobs:
   \* lista de jobs *\

workflows:
  'Test, Build and Deploy Workflow':
    jobs:
      - unit-test:
      - integration-test:
      - code_analysis:
          requires:
            - unit-test
            - integration-test
          context: sonarqube
      - build:
          requires:
            - unit-test
            - integration-test
      - heroku/deploy-via-git:
          requires:
            - build
          filters:
            branches:
              only: master

Não se esqueça de configurar o seu arquivo Procfile do Heroku :) no meu caso ficou assim:

web: java -jar build/libs/projeto.jar -port=${PORT}

Com o deploy configurado, temos a última etapa que seria o teste de API após o deploy para verificar se os endpoints da aplicação continuam funcionando corretamente (nesse exemplo, temos apenas um ambiente, mas seria interessante executar os testes de API em um ambiente de desenvolvimento ou staging antes do deploy ser executado em produção).

Para essa etapa, utilizei a Orb do CircleCI chamada Postman Newman no qual lê uma collection.json de um determinado path e executa.

Como é uma orb, devemos adiciona-lá no arquivo config.yml

version: 2.1

orbs:
  heroku: circleci/heroku@1.2.2
  newman: postman/newman@0.0.2
jobs:
   \* lista de jobs *\

Agora vamos adicionar o job correspondente ao nosso teste de API:

 api-test:
    working_directory: ~/
    executor: newman/postman-newman-docker
    steps:
      - checkout
      - newman/newman-run:
          collection: postman/projeto-collection.json
          environment: postman/projeto-environment.json

A propriedade environment contém a URL que foi gerada no Heroku durante o deploy.

No final o pipeline deve ficar dessa forma no CircleCI:

Arquivo config.yml completo:

version: 2.1

orbs:
  newman: postman/newman@0.0.2
  heroku: circleci/heroku@1.2.2

jobs:
  unit-test:
    working_directory: ~/
    docker:
      - image: circleci/openjdk:11-jdk-stretch-node-browsers
    steps:
      - checkout
      - run:
          name: Unit tests
          command: ./gradlew unitTest

  integration-test:
    working_directory: ~/
    machine: true
    environment:
      JAVA_HOME: /usr/lib/jvm/java-11-openjdk-amd64
      JAVA_TOOL_OPTIONS: "-Xmx4G"
      GRADLE_OPTS: "-Xmx4G -Dorg.gradle.daemon=false -DdisablePreDex"
    steps:
      - run:
          name: Download Java 11
          command: |
            sudo apt update
            sudo apt install openjdk-11-jdk
      - checkout
      - run:
          name: Integration tests
          command: ./gradlew integrationTest
  code_analysis:
    docker:
      - image: circleci/openjdk:11-jdk-stretch-node-browsers
    steps:
      - checkout
      - run:
          name: Sonarqube analysis
          command: ./gradlew sonarqube

  build:
    working_directory: ~/
    machine: true
    steps:
      - checkout
      - restore_cache:
          keys:
            - v1-dependencies-{{ checksum "build.gradle.kts" }}
            - v1-dependencies-
      - run:
          name: Run assemble
          command: ./gradlew clean assemble
      - save_cache:
          paths:
            - ~/.gradle
          key: v1-dependencies-{{ checksum "build.gradle.kts" }}

  api-test:
    working_directory: ~/
    executor: newman/postman-newman-docker
    steps:
      - checkout
      - newman/newman-run:
          collection: postman/collection.json
          environment: postman/environment.json

workflows:
  'Test, Build and Deploy Workflow':
    jobs:
      - unit-test
      - integration-test
      - code_analysis:
          requires:
            - unit-test
            - integration-test
          context: sonarqube
      - build:
          requires:
            - unit-test
            - integration-test
      - heroku/deploy-via-git:
          requires:
            - build
          filters:
            branches:
              only: master
      - api-test:
          requires:
            - heroku/deploy-via-git

Arquivo build.gradle.kts completo:


plugins {
    kotlin("jvm") version "1.3.61"
    id("org.sonarqube") version "3.0"
}

sonarqube {
    properties {
        property("sonar.projectKey", "chave do projeto"
        property("sonar.organization", "organization")
        property("sonar.host.url", "https://sonarcloud.io")
    }
}

tasks {
    create("stage", Task::class) {
        dependsOn("installDist")
    }

    create("unitTest", Test::class) {
        filter {
            includeTestsMatching("br.com.projeto.core.*")
        }
        testLogging {
            events(TestLogEvent.PASSED)
            events(TestLogEvent.FAILED)
        }
    }

    create("integrationTest", Test::class) {
        filter {
            includeTestsMatching("integration.*")
        }
        testLogging {
            events(TestLogEvent.PASSED)
            events(TestLogEvent.FAILED)
        }
    }

}

Esse foi apenas um exemplo do que é possível fazer com o seu pipeline, existem vários outros jobs que podem ser adicionados como lint, gerar documentação, smoke testes, automatização de comandos do git, basta usar sua imaginação :)

Espero que esse post tenha te ajudado de alguma forma.

Muito obrigado por ler esse post, caso tenha ficado com alguma dúvida ou tenha alguma sugestão, sinta-se livre para deixar um comentário 😀