DEV Community: Javeiro

30 dias aprendendo UI/UX

Javeiro — Tue, 21 Feb 2023 01:04:18 +0000

É isso mesmo galera, eu não sai do Java blz? haha, mas acontece que, meus projetos estavam muito sem profundidade, e chegou o momento de aprender logo design, pelos menos para entender e conseguir realizar algo da forma que eu quero, sem dependender de terceiros!!

E olha só, já tem 4 dias que estou estudando UI/UX e estou dando meus primeiros passos, espero aprender com a comunidade de designers e gerar projetos que no futuro possa me orgulhar!

Eu tambem tenho um projeto que vou realizar com a comunidade do twitter, que no final, vai render um CRUD com springboot e quero esse blog com deploy para publicar meu artigos!

Resultado dos primeiros 4 dias abaixo!

5° Dia de aprendizado:

Então, seguindo essa saga de UI/UX, hoje aprendi com mão na massa, seguindo a recomendação do professor da Origamid, um projeto esboço ao lado, e tudo que aprendi com ele, eu precisava refazer com aquilo que acreditava que era possivel refazer... Abaixo segue o esboço do professor:

E aqui segue o meu wireframe da forma que acreditei que era seguindo a atividade:

É isso, em pleno carnaval e estudando para no fim conseguir ter habilidades suficientes de produzir meu blog e um site portfolio, eae, acha que consigo em 30 dias?

Hello world um pouco por trás dos panos

Javeiro — Tue, 15 Mar 2022 00:46:28 +0000

Falando do famoso "Hello World" .
Bom... a primeira coisa que nos deparamos ao interagir com alguma linguagem é o famoso hello world, e no java não foge a regra, ora, mas como funciona um pouco mais por tras dos panos ele?
Aqui tento explicar um pouco os passos para a criação até a execução da classe Hello world

No geral temos 5 fases que o programa passam até rodar de fato sua instrução, sendo elas, edição, compilação, carregamento, verificação e execução.

A primeira parte se resume a criar um arquivo com um programa editor. usando esse editor, faz as edições e correções necessárias e o salvamos em um dispositivo de armazenamento secundário, até aqui pense no seu disco rígido(Hd). Um nome
de arquivo que termina com a extensão .java é indicado que o arquivo contem o código-fonte java.
Na compilação o compilador cria bytecodes e os armazena em disco, o arquivo com o nome atribuído termina .class, após isso, temos o carregamento onde o carregador de classe lê os arquivos .class que contêm bytecodes a partir do disco
e coloca esses bytecodes na memoria. O verificador de bytecode confirma que todos os bytecodes estão validos e não será violado restrições de segurança do Java. E por fim a execução, a JVM lê os bytecodes e compila no momento correto,
famoso (Just In Time- JIT) para que o computador possa entender.
Ok... agora sabemos como é realizado a execução de um simples programa, e olhando um pouco mais para o arquivo hello world, o que encontramos ?
Normalmente para escrever o simples hello world, será preciso fazer isso aqui :

class HelloWorld{ public static void main(String[] args){ System.out.println("Hello World"); // exibe a string } }

Podemos dizer que temos 2 componentes, nossa definição de classe e o main método.

a forma mais básica para definirmos nossa classe será :

class HelloWorld{ ... }

nossa palavra class inicia uma definição de classe chamado HelloWorld e o código para cada classe aparece entre as chaves.

Main método

Na linguagem de programação java toda aplicação deve conter um main método, e seguir essa assinatura :
Algo curiosos é que os modificadores de acesso podem ser escritos em qualquer ordem, porem a convenção é usar public static, nos argumentos podemos nomear como quiser, mas sempre é definido como args ou argv.
O main método é parecido com main função do C, é ponto de entrada do aplicativo e logo, invocara métodos exigidos pelo programa.
O main método ele aceita o argumento, que é uma array com elementos do tipo String, matriz na qual o sistema de tempo de execução passa informações para o app.

public static void main(String[] args){ ... }

Por fim a saída dos dados :
É usado a System da biblioteca principal para imprimir o "Hello World", biblioteca essa tambem conhecida como Application Programming Interface ou API.

System.out.println("Hello World");

Obtendo repositório git

Javeiro — Tue, 22 Feb 2022 02:34:19 +0000

Se você vem acompanhando a sequencia de artigos relacionados a git, então já conseguiu avançar bastante com nossos estudos, agora vamos cobrir comandos básicos do git e assim continuando nossa sequencia de estudos do terminal. Ao final desse artigo acredito que tenha uma base para iniciar seu repositório, iniciar e interromper os rastreamento de arquivos e assim fazer os commits das suas alterações, como desfazer de erros comuns, fazer push e pull nos seu repositório.

Criando seu repositório Git

Existe duas maneiras de você ter seu repositório git, a primeira é você pegando um repositório e tornando ele um repositório git, 2. e a segunda é você fazendo o clone do repositório que já existe em outro lugar.

Iniciando um projeto git dentro de um diretório existente

Para começar a monitorar o git você precisa navegar até o diretório desejado, caso nunca tenha feito isso deixo o comando abaixo :

linux:

$cd /home/user/seu_repositorio

Windows:

$cd /c/user/seu_repositorio

logo após isso, digite :

$ git init
com esse comando cria um subdiretório .git. Nele se verificarmos estão todos os arquivos necessários para iniciar o repositório, basicamente o esqueleto do GIT, bom e não se engane, até esse momento os seus arquivos ainda não estão sendo monitorados.
Para começar a monitorar seus arquivos você precisa git add, exatamente esse comando passa seus arquivos agora para area de stage seguido do git commit para fazer seu comentário do arquivo monitorado :

$ git add .
$ git commit -m "projeto inicial"

Não se preocupe que falaremos o que esses comandos fazem, mas se atente que até nesse primeiro momento, você já tem os comandos necessário para iniciar seu projeto e publicar no GitHub

Então como clonar o repositório existente ?

Ok, agora que você já tem o básico de comandos e seu foco nesse momento é contribuir para algum projeto, e usar o que aprendeu com todos os comandos acima, o que você precisa fazer é usar o comando no seu CLI git clone. Como seu primeiro contato ou não, entenda que o git clone como o próprio comando diz, ele vai clonar o projeto totalmente para sua maquina local, todos os dados que estão nesse repositório que você escolheu do servidor. E cada versão de cada arquivo tambem é obtido quando você executa o comando git clone.
Como seria na pratica ? vejamos, aqui digamos que vamos clonar um repositório que vamos usar de exemplo, dadas condições já sabemos que o comando git clone [url] é o que vai proporcionar o clone do projeto.
Vamos usar de exemplo um repositório que criamos para esse teste e o servidor será o GitHub :

Na pagina inicial do GitHub, vá até repositórios ou simplesmente clique na aba + :

No repositório que escolher clique no botão verde escrito code e copie uma das 3 opções, eu particularmente indico usar https até se familiarizar com o github

Escolha onde vai deixar vai trazer o conteúdo clonado e inicie o git bash here como no exemplo, no meu caso utilizei da área de trabalho para trazer os dados do repositório:

Com o terminal iniciado, insira o comando git clone e com o botão direito cole os dados copiados do servidor GitHub

$ git clone [url]

*Detalhe: a sua URL vai ficar diferente da minha ok ?😃

E para entrar no seu diretório, insira o comando:

$ git cd [nome do projeto]

o comando cd vai acessar outras pastas e com isso a frente dele inserimos o nome do projeto clonado

Pronto, agora temos o repositório que desejamos contribuir😃

JDK, JVM, JRE para que serve ?

Javeiro — Sun, 13 Feb 2022 16:31:32 +0000

JVM (JAVA VIRTUAL MACHINE)

Java(codigo fonte) -> compilador(javac) -> bytecode -> JVM = executar

Quando passado o bytecode para a Java virtual machine, ela compreende seu código e interpreta e executa, então compreendemos que o código fonte é passado para o JAVAC e compilado e gerado um bytecode e quando passado para a JVM, ela interpreta e executa nas plataformas de software.

JAVAC: então para sanar duvidas o JAVAC é o compilador primário da linguagem JAVA

JRE(JAVA RUNTIME ENVIRONMENT)

o JRE é composto por 2 partes, a JVM e bibliotecas e é utilizado para executar as aplicações da plataforma Java

o que compõe uma JVM ?

Loader / Verificador

Loader: é a parte interna da sua JVM que carrega o bytecode na memoria da maquina virtual.

Verificador: ele faz uma verificação se o código pode ser interpretado sem nenhum problema.

Interpretador / Gerenciador / JIT

Interpretador: Ele vai pegar seu código em ByteCode e transformar em código nativo
do seu sistema operacional. na maquina que estiver ele converte o código em Bytecode
em uma instrução que seu sistema operacional compreenda

Gerenciador: Trata como os códigos e variáveis serão gerenciados dentro da JVM

Compilador JIT: a cada trecho de código é traduzido no instante em que está para ser
executado

JDK(JAVA DEVELOPMENT KIT)

O JDK é composto pelo compilador e bibliotecas(API's) necessárias para criação de programas em Java, e ferramentas uteis para o desenvolvimento e para testes dos programas escritos por esta linguagem de programação.
Dentro do JDK já temos incluso o JRE e todos seus componentes, a Java LANG e Java Tools e Debugger.

Configurações iniciais

Javeiro — Mon, 07 Feb 2022 23:32:19 +0000

Se você tem acompanhado os posts e seguidos os tutoriais, já deve ter o git em sua maquina local. Nesse momento vamos configurar o seu git e manter atualizado na sua maquina, essa configuração é dada apenas uma vez e não necessita de mais alterações, entretanto, nada impede de alterar caso seja necessário, com comandos simples já podemos altera-los novamente.

A ferramenta que vamos utilizar é a git config que permite definir variáveis de configuração que controlam todos os aspectos da aparência do Git. As variáveis se encontram em 3 lugares diferentes:

[path]/etc/gitconfigfile: Contém valores aplicados a todos os usuários do sistema e a todos os seus repositórios. Se você passar a opção --system para git config, ele lê e grava especificamente no arquivo. Como este arquivo de configuração do sistema, você precisaria de privilégios administrativos de super usuários para fazer alterações nele.
~/.gitconfigou ~/.config/git/configfile: Valores específicos para você o usuário, Você pode fazer o git ler e gravar neste arquivo especificamente passando a --global opção, e isso afeta todos os repositórios com os quais você trabalha em seu sistema.
configfile no diretório Git(ou seja, .git/config) de qualquer repositório que você esteja usando atualmente: Especifico para esse único repositório. Você pode forçar o Git a ler e gravar neste arquivo com a --local opção, mas esse é o padrão. Sem essa surpresa, você precisa estar localizado em algum lugar em um repositório git para que esta opção funcione corretamente.

Voce pode ver todas as suas configurações e de onde elas vêm usando:

$git config --list --show-origin

Sua Identidade

Primeira coisa depois da instalação do git é definir o nome de usuario e endereço de email. É importante porque todos os commits usam essas informações e são incorporados naquilo que voce comeca a criar

$ git config --global user.name "Darlan Onorio"
$ git config --global user.email "emailexemplo@exemplo.com"

Voce apenas precisa fazer isso uma vez na --global, a partir daí o git usara essa informação para qualquer informação que voce fizer no sistema. Se voce quiser substituir isso por um nome ou endereço diferente para projetos especificos, podera executar o comando sem a --global opção quando estiver no projeto.

Como Alterar o nome de filial padrão(branch)

Por padrão, o git criará uma branch chamado master quando você criar um novo repositório com git init. A partir da versão 2.28 do git. você pode definir um nome diferente para o branch inicial

$ git config --global init.defaultBranch main

Verificando suas configurações

Se você quiser verificar suas configurações, você pode usar o git config --list comando para listar todas as configurações que o git pode encontrar nesse ponto

$ git config --list

Instalando git

Javeiro — Mon, 31 Jan 2022 23:01:13 +0000

Antes de começar a usar o git. Você precisa ter o software em sua maquina local, você pode instalar por meio de um pacote instalador executável.

Instalando no Linux

Se voce deseja instalar as ferramentas do git no linux, geralmente pode faze-lo por meio da ferramenta de gerenciamento de pacotes que acompanha sua distribuição. Se estiver no fedora(ou qualquer distribuição RPM relacionada com RHEL ou CentOS), voce pode usar dnf

Caso esteja em uma distribuição baseada em debian, como Ubuntu, tente apt:

Instalando no Windows

Existe também a maneira de instalar no windows. As versões mais recentes do software, você encontra no site oficial.

link para download:

https://git-scm.com/download/win

logo depois, pode executar o instalador e prosseguir as etapas de instalação

Linha de Comando

Javeiro — Mon, 31 Jan 2022 15:14:39 +0000

Existem muitas maneiras de usar o git. Desde interfaces gráficas a linhas de comando(vamos aprender isso). A linha de comando é onde vamos executar a maiorias do comandos git - existe as ferramentas do GUI, mas traz um pequeno subconjunto de ferramentas necessários para produção, afinal... o que é GUI ? de uma forma bem resumida, o GUI é uma interface gráfica que traz algumas funcionalidades com ele, mais a frente vamos abordar ele, portanto, não se preocupe se não entendeu totalmente. Prosseguindo, se você souber as funcionalidades da linha de comando do prompt, provavelmente sabe utilizar o GUI, e isso já não acontece quando contrario, logo, temos como foco aprender todas as funcionalidades do git para que você domine essa ferramenta poderosa.

Portanto, espero que você já saiba ou já tenha tido contato com o prompt de comando ou powershell ou até mesmo no MacOS. Caso contrario procure alguns tutoriais básicos para sanar suas duvidas a prompt de comando e assim prosseguir com nossos estudos.

O que é Git

Javeiro — Sat, 29 Jan 2022 04:22:39 +0000

Ok... Então avançamos para essa parte importante, e a pergunta é o que é git ? Esta seção é bastante importante por que até certo ponto você já entendeu a historia do git e como foi aplicado outros softwares anteriores ao git. De fato estamos se aprofundando aos conceitos e entendendo como usa-lo efetivamente, será muito mais fácil para você. Não se atente ao primeiro momento sobre outros VCSs, CVS, SubVersion ou Peforce - com isso evitamos confundir ao usar a ferramenta. Embora sejam semelhantes a essas ferramentas, o Git pensa e performa de uma maneira muito diferente, e entender essas diferenças ajuda a evitar essas confusões.

Instantâneos, não diferenças

O git tem uma característica que o destaca de outros CVS(Subversion e amigos) é a maneira de como pensado os seus dados. No geral os sistemas armazenam seus dados como uma lista de alterações com base em arquivo. Os outros sistemas (CVS, Subversion, Perforce, Bazaar e outros) consideram as informações como arquivos em conjunto e as alterações feitas em cada arquivo ao longo do tempo.

Figura acima: Armazena dados como alterações em uma versão base de cada arquivo.

O Git não pensa ou armazena os seus dados dessa maneira. O Git pensa em seus dados como uma serie de instantâneos de um sistema de arquivos em miniatura, para ficar mais claro o exemplo dado, voce pode pensar que toda a vez que você confirma ou salva o estado do seu projeto, o Git tira basicamente uma foto de como estão todos os seus arquivos naquele momento e armazena uma referencia a esse instantâneo. Garantindo mais eficiência, e caso esse arquivo não for alterado, o Git não armazena novamente, o git pensa como um fluxo de instantâneos.

figura acima ilustra forma de armazenar dados como instantâneos do projeto ao longo do tempo.

A diferença entre Git e quase todos os outros VCSs, é que quase todos os aspectos do Git foram reconsiderados em relação aos outros VCSs que somente copiaram de gerações anteriores. O Git vai muito além do que somente um VCS.

Maioria das operações são locais

A maioria do fluxo de trabalho no git precisa apenas de arquivos e recursos locais para operar - normalmente não necessita de outra informação de outro computador em sua rede. E caso ainda tenha lembranças dos CVCS em que a maioria das vezes tenha operações com sobrecarga sobre latência de rede, com toda essa velocidade faz você tenha todo o histórico do git em seu disco local, as operações são quase instantânea.

Para navegar no seu histórico por exemplo, você não precisa ir ao servidor e fazer toda a procura para exibi-lo, ele simplesmente lê o banco de dados local e o exibe. Tendo acesso ao histórico do projeto quase que instantâneo. E se tiver alguma alteração mais antiga no banco de dados local o git pode fazer o calculo para você e ter sua diferença local, em vez que ter que pedir autorização para um servidor ou vá até o servidor remoto antigo do arquivo remoto.

Também significa que há muito pouco que NAO possa se fazer off-line ou sem VPN. você pode trabalhar de qualquer lugar e modificar o seu arquivo, até chegar em uma conexão de rede para fazer o upload. E caso você não consiga se conectar a rede, significa que consegue trabalhar normalmente no projeto até poder subir suas alterações. Em outros sistemas, fazer isso é impossível. No peforce, por exemplo, você não pode fazer muito quando não conectado no servidor, No subversion e no CVS, você pode editar arquivo, mas não pode enviar alterações para seu banco de dados(porque ele esta off-line).

Git tem integridade

Tudo no Git passa por uma soma de verificação antes de ser armazenado e é então referenciado por essa soma de verificação. Isso significa que é imp0ossivel alterar o código antes que o git não saiba. Funcionalidade essa que foi adicionada ao Git nos níveis mais baixos e é parte principal de sua filosofia. Você não perde informações ou obtém arquivo corrompidos sem que o Git tenha detectado

Mecanismo esse usado é chamado de hash SHA-1. abaixo tenho um exemplo de uma string de 40 caracteres composta por caracteres hexadecimais(0-9- e a-f) e calculada com de um diretorio git, um hash SHA-1, Se parece com isto:

    ``24b9da6552252987aa493b52f8696cd6d3b00373``

Você vai encontrar números parecidos em todos os seus projetos, o Git armazena tudo em seu banco de dados não pelo nome do arquivo, e sim pelo valor do seu hash.

Git Geralmente apenas adiciona dados

Quando você faz algo no Git, quase senão todas elas são adicionadas ao banco de dados Git. E dificilmente o sistema possa fazer algo que possa ser desfeito ou apague os dados de alguma forma. você pode perder alterações que ainda não fez, mas depois de fazer o commit de um SNAPSHOT no Git, é muito difícil perder, com maior dificuldade se você envia regularmente para seu banco de dados.

E com isso torna o git mais seguro, sabendo que podemos alterar o arquivo tendo total consciência que podemos retornar ao estado anterior e recuperar todas as alterações.

Os Três Estados

Três Estados principais que precisam ser lembrados no Git. modificado, preparado e confirmado.

Modificado: significa que você alterou alterou o arquivo, mas ainda não confirmou em seu banco de dados
Staged: significa que você marcou um arquivo modificado em sua versão atual para entrar no snapshot do commit.
Comprometido: significa que os dados local estão guardados em seu banco de dados com segurança

Figura: Área de trabalho, área de teste e diretório Git

Arvore de trabalho é o único checkout da versão do projeto. Os arquivos são retirados do banco de dados compactado no diretório Git colocados no disco para você usar ou modificar.

A área de teste é um arquivo, em geral esta em seu .git, e vai armazenar informações sobre seu próximo commit, o nome técnico dele é "índice".

O diretório Git é onde armazena os metadados e o banco de dados de objetos do seu objetos do seu projeto. parte mais importante do Git, e é o que é copiado quando você clona um repositório de outro computador.

fluxo de trabalho básico do git:

Você modifica arquivos em sua arvore de trabalho
Você prepara seletivamente apenas as alterações que deseja que façam parte do seu próximo commit
Você faz um commit, que pega os arquivos como eles estão na área de teste e armazena nesse snapshot permanentemente em seu diretório Git

Historia do Git

Javeiro — Fri, 28 Jan 2022 15:12:51 +0000

Breve Historia do git

O git já começa com uma historia bastante controvérsia e criativa.

O kernel Linux é um projeto de código aberto. Durante os primeiros anos da manutenção do Linux(1991-2002), todas as mudanças eram passadas como patches e arquivos arquivados. Em 2002, o projeto começou a usar um DVCS proprietário chamado BitKeeper.

Em 2005, o relacionamento entre ambos quebrou, e o status de gratuito foi revogado, ou seja, produziram um software com acesso por um tempo e logo depois decidiram o acesso pago. Isso levou a comunidade de desenvolvimento do linux(enfase ao Linus Torvalds, o criador do Linux) a desenvolver seu próprio software com base no que aprenderam com o BitKeeper. Objetivos do novo sistema foram :

Velocidade
Design Simples
Forte suporte para desenvolvimento não linear(ramificações paralelas)
Totalmente distribuído
Capaz de lidar com projetos grandes de forma eficiente(velocidade no tamanho dos dados)

Desde 2005 dada a criação do git, ele amadureceu para fácil usabilidade e manter as qualidades iniciais. É eficiente com projetos grandes e possui um sistema de ramificação com ótimo desempenho para desenvolvimento não linear.

Introdução Sobre controle de versão

Javeiro — Thu, 27 Jan 2022 21:55:09 +0000

Este é o primeiro capítulo da ferramenta git. Começaremos com informações básicas sobre controle de versão, depois passaremos para como fazer rodar o git em seu sistema, logo depois, como configurar e começar a trabalhar com essa ferramenta que é essencial na vida dos programadores. No final dessa serie de artigos você devera ser capaz de entender por que git existe, porque deve usar e estar preparado para usa-lo.

Sobre o controle de versão

O que você acredita ser controle de versão ? você acha que deve ser importante? Mas afinal... o que é controle de versão ?
O controle de versão é um sistema que registra arquivos ou conjunto de arquivos ao longo do tempo para que você possa recuperar versões anteriores do seu arquivo ou projeto posteriormente.

Se você deseja manter versões de uma imagem ou código, o sistema de controle de versão (VCS) é o mais apropriado para isso.
Com ele você pode reverter arquivos que não eram para alterar e recuperar para seu estado anterior, comparar alterações ao longo do tempo, ver quem modificou a ultima vez algo que estar causando problema, quem inseriu um problema no código ou solução também e muito mais.

E usando um VCS significa que caso você estrague o projeto, com apenas um comando já retornara ao estado anterior e funcionando.

Sistema de controle de versão local

O método de controle de versão preferido de muitas pessoas é de copiar arquivos para outro diretório, ou seja apenas copiar toda a pasta e ter 2 arquivos. Essa forma de versionar é muito simples e comum, contudo fácil e propenso a erros. Por que é fácil esquecer o diretório original e assim gravar o projeto em outra pasta.

Para lidar com esse tipo de problema, programadores há anos atrás desenvolveram VCSs locais que tinham um banco de dados simples que guardavam as alterações em arquivos sob controle de versão

Naquele momento foi muito popular a ferramenta VCS chamada RCS, hoje ainda é distribuído em muitos computadores. O RCS funciona mantendo Patches, de modo geral, as diferenças de arquivos em um formato de disco.

Sistemas de controle de versão Centralizados

O problema que encontraram é que as pessoas precisam colaborar com desenvolvedores em outros sistemas. Com isso, foi desenvolvido Sistemas de Controle de Versão Centralizados(CVSs). Eles como os (CVS) tem um único servidor quem contem todos os arquivos, com versão de vários clientes, e sim, ele foi usado durante anos como versionador.

Abaixo a figura ilustra o funcionamento :

As Vantagens são que todos sabem até certo ponto o que todos no projeto estão fazendo. Os administradores tem controle sobre tudo, ou seja, quem pode fazer o que, e o que era mais fácil de lidar com esse tipo de trabalho.

Pontos negativos:

Suponhamos que o servidor fique inativo no período de 2 horas, dentro desse tempo você não pode colaborar ou salvar alterações no projeto. Caso o disco rígido seja corrompido, todas as alterações serão perdidas, absolutamente tudo no projeto será perdido, salvo aquelas que estão na maquina local de cada colaborador

Sistemas distribuídos de controle de versão

Aqui falamos sobre os sistemas de controle de versão distribuidos(DVCSs). Em um DVCS(git, Darcs ou Mercurial), os clientes verificam não somente a ultima alteração de versionamento, mas sim como o todo histórico do projeto, e partes anteriores tendo o histórico completo. E caso algum servidor morrer e os sistemas estiver colaborando por meio desse servidor, Pode ser facilmente recuperado e copiado de volta para o servidor. Cada clone é um backup completo dos dados