Ferramentas recomendadas

Ferramentas recomendadas são aquelas que muitos desenvolvedores, independentemente de linguagem, plataforma ou aplicação, deveriam aprender.

Escolha, no índice, a ferramenta que você procura.

Sistema de Versionamento Git

Sobre

Este não é um tutorial para você aprender Git. Caso seu objetivo seja aprender, siga o Git Book (não se assuste com o tamanho dele: leia com carinho e atenção, é um livro muito bom que irá ensiná-lo a utilizar Git corretamente).

Para que este tutorial então? Para servir de consulta rápida dos comandos do Git, tendo pequenos exemplos e pequenas descrições do que você possivelmente quer fazer.

Comandos básicos

Inicializar uma pasta como repositório Git:

git init

Checar o estado atual das alterações do repositório:

git status

Adicionar um espelho remoto:

git remote add nome link

Atualizar repositório local a partir do remoto:

git pull

Atualizar repositório remoto a partir do local:

git push nome-do-remoto branch-remoto

Relacionar branch atual com um branch remoto (para atualizar com git push/git pull sem precisar especificar o remoto e branch):

git push --set-upstream nome-do-remoto branch-remoto

Adicionar alterações de um arquivo ao próximo commit (OBS: também utilizado para indicar que foi removido):

git add arquivo1 arquivo2 ...

Criar commit com as alterações adicionadas:

git commit -m "Mensagem do commit"

Identificar autor dos commits apenas no repositório atual:

git config user.name "Nome do autor"
git config user.email "E-mail do autor"

Identificar autor dos commits para todos os repositórios do usuário logado no computador:

git config --global user.name "Nome do autor"
git config --global user.email "E-mail do autor"

Exemplos

Inicializar repositório a partir do zero

Sendo "~/" a pasta do usuário atual:

~/ $ mkdir example
~/ $ cd example
~/example $ git init
Initialized empty Git repository in /home/user/example
~/example $ git remote add origin https://github.com/pet-comp-ufsc/git-example
~/example $ git push --set-upstream origin master

Inicializar repositório a partir de um remoto

Método 1

Para quando:

Você não tem o projeto localmente; e
Você quer que o nome da pasta seja o mesmo do repositório.

~/ $ git clone https://github.com/pet-comp-ufsc/git-example
~/ $ cd git-example
~/git-example $

Método 2

Para quando:

Você não tem o projeto localmente; e
Você quer dar um nome específico para a pasta do projeto.

~/ $ git clone https://github.com/pet-comp-ufsc/git-example example
~/ $ cd example
~/example $

Para quando:

Você tem o projeto localmente; e
Você quer relacioná-lo ao remoto.

~/ $ cd example
~/example $ git init
Initialized empty Git repository in /home/user/example
~/example $ git remote add origin https://github.com/pet-comp-ufsc/git-example
~/example $ git pull origin master

Ferramentas específicas

Java

JDK

Índice

Sobre

O JDK (Java Development Kit) é um conjunto de programas para desenvolvedores poderem compilar, depurar e analisar códigos escritos em Java. Trata-se das ferramentas oficiais da linguagem para desenvolvimento, atualmente desenvolvida pela Oracle.

Instalação

Informações gerais

Versão sugerida: OpenJDK-10 (mais recente)

Instalar no Windows

Siga para a página de download oficial da Oracle e clique no botão "Download" com o ícone de Java 10.
Na seção cinza com o título "Java SE Development Kit <Versão>", marque "Accept License Agreement";
Clique no link de download para Windows (que termina em ".exe).
Execute o arquivo baixado.
Teste se a ferramenta está no PATH.

Instalar no Linux

Ubuntu

Siga as instruções nesta resposta, porém considere a versão sugerida acima no lugar.

ArchLinux

Execute o comando:

pacman -S jdk10-openjdk

Como utilizar

Compilar

(OBS: Se as classes que você irá compilar estão em um package, veja o tutorial Como trabalhar com pacotes para saber como compilá-los da maneira correta)

Compilar no Windows

Para compilar um arquivo de código Java:

Abra um cmd na pasta em que se encontra o arquivo de código. Isso pode ser feito de duas formas:
1. (Windows 8 e 10) Abrindo a pasta pelo Windows Explorer, indo em "Arquivo" e "Abrir prompt de comando aqui";
2. Abrindo um cmd (tecle Windows+R, digite "cmd" e dê um Enter) e inserindo o comando:
```
> cd "Pasta em que está o arquivo"
```
  Exemplo: se o arquivo está na pasta "Testes com Java" em "Documentos":
```
> cd "Documentos/Testes com Java"
```
  Exemplo 2: se o arquivo está em um pendrive na unidade "E:", na pasta "E:/dev/java":
```
> E:
> cd dev/java
```
Execute o comando javac <nome do arquivo>.java:

Exemplo: se o arquivo se chama "HelloWorld.java":
```
> javac HelloWorld.java
```

Compilar no Linux

Para compilar um arquivo de código Java, execute:

cd "pasta/em/que/está/o/arquivo/de/código"
javac NomeDoArquivo.java

Exemplo: se o arquivo "HelloWorld.java" está na pasta "~/dev/java/learn/":

cd ~/dev/java/learn
javac HelloWorld.java

Executar um código compilado

Primeiramente, é necessário ter o JRE instalado. Os passos de instalação são os mesmos que o do JDK, porém trocando "JRE" por "JDK" (exceto na instalação para Ubuntu).

Apenas vá até a pasta em que se encontra o código e execute:

java NomeDaClasseComOMain

Exemplo: Se o arquivo compilado foi "HelloWorld.java", ele terá gerado um "HelloWorld.class", sendo assim, basta executar:

java HelloWorld

Se a classe se encontra em um package, é necessário ir até a pasta antes do pacote e executar java pacote.Classe.

Exemplo: Supondo a estrutura de pastas:

`- myproject
   `- src
      `- mypackage
         `- MyClass.java

Teríamos que ir até a pasta "myproject/src" e executar:

javac mypackage/MyClass.java

Isso irá criar um arquivo "MyClass.class" dentro de "mypackage" (caso queira, veja como Alterar para onde vão os arquivos .class):

`- myproject
   `- src
      `- mypackage
         |- MyClass.class
         `- MyClass.java

Sendo assim, bastaria executar:

java mypackage.MyClass

Alterar para onde vão os arquivos .class

(TODO)

Gerar .jar

Arquivos .jar são como .zip, porém feitos para conter bytecode Java. Podem ser utilizados tanto para ter programas executáveis (instruindo qual classe contendo o método main será chamada ao executar) quanto para oferecer bibliotecas para outros programadores.

Para gerar um arquivo .jar a partir de arquivos .class, basta utilizar o comando:

jar --create --file NomeDoArquivo.jar --no-manifest Arquivo1.class Arquivo2.class ...

O comando acima irá criar um arquivo novo com o nome especificado, sendo que:

--create: Indica que o arquivo será criado. A flag --update pode ser utilizada no lugar para atualizar um .jar já existente.
--file: Indica que o argumento que virá na sequência é o nome do arquivo .jar. Por exemplo: --file Hello.jar irá indicar que a operação será feita em um arquivo chamado "Hello.jar".
--no-manifest: Indica que não há um arquivo Manifest dando instruções sobre o .jar (como qual classe contém o main).

Tendo o arquivo "NomeDoArquivo.jar" criado, ele pode ser incluído no ClassPath de outros programas em Java para ser utilizado como biblioteca, por exemplo:

javac -cp $CLASSPATH:NomeDoArquivo.jar OutroArquivo.java

Quanto ao arquivo Manifest, é possível criar um arquivo com nome "manifest.txt" (por exemplo) contendo:

Main-Class: pacote.Classe;

E, com ele, chamar jar com a flag --manifest com seu nome:

jar --create --file Arquivo.jar --manifest manifest.txt Classe.class

E, com isso, é estabilizada como classe principal a pacote.Classe. Assim, ao se executar o .jar:

java -jar Arquivo.jar

E assim o método main da classe indicada em Main-Class (no exemplo: pacote.Classe) será chamado.

Na documentação da Oracle sobre Arquivos Manifest é possível encontrar mais informações a respeito.