Java - fibonnaci number

In mathematics, the Fibonacci numbers are the numbers in the following integer sequence, called the Fibonacci sequence, and characterized by the fact that every number after the first two is the sum of the two preceding ones.
Source: Wikipedia.

Fibonacci numbers can be represented in the following formula:
F(n) = F(n-1) + F(n-2)

F(1) = 1
F(2) = 1
F(3) = F(2) + F(1) -> 1 + 1 = 2
F(4) = F(3) + F(2) -> 2 + 3 = 5

The algorithm that I will show here is not recursive:

  
public static int fibonnaci(int number) {

    if (number <= 2) {
        return 1;
    }

    int previous = 1;
    int result = 1;

    for (int i = 3; i <= number; i++) {
        int temp = result;
        result = previous + result;
        previous = temp;
    }

    return result;

}

Java - check if a string is a palindrome

"A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward or forward, such as madam or kayak." Wikipedia.

Today I will show you a algorithm to find out if a string is a palindrome or not, the algorithm is pretty straightforward and does not need much explanation. It runs Big O(n) and isn't case sensitive:

If you want test cases you can visit http://www.palindromelist.net/ and test if a phrase is or isn't a palindrome.

     /**
     * Verify if the value is a palindrome. The algorithm is not case sensitive and only compare words.
     * The algorithm runs in big O(n).
     *
     * @param value that represent a palindrome
     * @return {@code value} is a palindrome
     */
    private static boolean isPalindrome(String value) {

        value = Optional.ofNullable(value).map(v -> v.replaceAll("\\W", "")).orElse("");

        if (value.isEmpty()) {
            return false;
        }

        final char[] chars = value.toCharArray();
        int length = value.length();
        for (int i = 0; i < length; i++) {

            char charI = Character.toUpperCase(chars[i]);
            char charJ = Character.toUpperCase(chars[length - i - 1]);

            if (charI != charJ) {
                return false;
            }
        }

        return true;
    }

Linux - Linha de Comando - Atalhos Ninjas

Alguns atalhos bacanas para quem usa a linha de comando no dia a dia e só está acostumado a usar "Home", "End" e "Delete" para digitar seus comandos. Segue alguns atalhos que vão fazer sua vida mais fácil:

Atalhos de sistema: 
Ctrl + Alt + T : Abre o terminal
Windows + E : Abre o home do usuário

Atalhos do terminal:

Ctrl + u : Deleta a linha da posição do cursor para o ínicio.

Ctrl + k : Deleta a linha da posição do cursor para o final.
Ctrl + w : Deleta a palavra anterior.
Ctrl + r : Muito útil para pesquisar no histórico dos seus últimos comandos digitados.

Ctrl + t : Corrige o que você quis dizer para o terminal, por exemplo, você queria escrever "vim" mas escreveu "vmi", digitando "Ctrl + t" o terminal irá corrigir para "vim".
Ctrl + Flexa Esquerda: Vai para o inicio da linha de comando. Mesma coisa que apertar "Home" no teclado.
Ctrl + Flexa Direita: Vai para o fim da linha de comando, mesma coisa que apertar "End" no teclado.
Tab : Completa o que você quer dizer para o terminal, não há necessidade de escrever tudo no terminal, por exemplo, você quer entrar na em um diretório "/home/diegogusava", você pode digitar "/h" digitar Tab e o shell irá completar para "/home".

Outro comando muito útil também é por exemplo poder executar o último comando sem a necessidade de executar tudo novamente só porque você esqueceu que ele precisava ser executado com permissão de root:

!! : executa o último comando novamente

$ ls /root
> ls: cannot open directory '/root/': Permission denied

$ sudo !!
> sudo ls /root/
> [sudo] password for diegogusava:

Seus próprios atalhos

É possível configurar seus próprios atalhos no arquivo do diretório do seu usuário chamado .bashrc , esse arquivo será executado pelo shell toda vez que você abrir um terminal. Por padrão o arquivo .bashrc já vem com alguns atalhos configurados para você:

alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

Caso você abra o arquivo .bashrc você verá que ele verifica se existe o arquivo .bash_aliases e caso ele exista ele também será considerado, por isso quando eu crio atalhos costumo colocar todos eles nesse arquivo.


Fontes:
http://lifehacker.com/5743814/become-a-command-line-ninja-with-these-time-saving-shortcuts
http://lifehacker.com/274317/turbocharge-your-terminal
http://www.skorks.com/2009/09/bash-shortcuts-for-maximum-productivity/



 

Linux - Pomodoro Script

I was looking for a app to use the pomodoro technique and I had not found anything valuable, but I found a blog post that create a bash script and I just increment the script a little bit and put on github.

So if you want to use the script just clone the https://github.com/diegogusava/pomodoro repository.

I also create a symbolic link on /usr/local/bin to point to the pomodoro script:

ln -s ~/my/path/pomodoro/pomodoro pomodoro

The full script

#!/bin/bash

clear

printf "Pomodoro (minutes): "
read pomodoro

printf "Rest (minutes): "
read rest

function loop() {
 time=$1
 while [ $time -gt 0 ] 
 do
  time=$(( $time - 1 ))
  now=$(date +"%T")
  sleep 1
  printf "$now: $(( $time / 60 )) minute(s) and $(( $time % 60 )) second(s) left\n"
 done
}

printf "New pomodoro starts. You have ${pomodoro} minute(s) to work.\n"

pomodoro=$(( $pomodoro * 60 ))
rest=$(( $rest * 60 ))

image=$(readlink -f pomodoro.png)

DISPLAY=:0 notify-send -t 1000 -i $image "New pomodoro starts" "You have 25 minutes to work."

loop $pomodoro

clear

now=$(date +"%T")

printf "Pomodoro ends at $now\n"

DISPLAY=:0 notify-send -t 1000 -i $image "pomodoro ends" "Take a rest!"

printf "Take a rest! Press any key to continue!!"

read whatever

loop $rest

now=$(date +"%T")

printf "Rest ends at $now\n"

Java e memória heap - Classes, quantidade de instâncias e tamanho ocupado

Gerando log de classes que estão na memória HEAP do Java

#!/bin/sh
#Criando log da quantidade de instancias que estão na memória heap

#PID do JBOSS
PID=$(/apps/jdk1.8.0/bin/./jcmd | grep /apps/jboss | awk '{print $1}')

#DATA NO FORMATO 2016-10-16--17-00
NOW=$(date +"%Y-%m-%d--%H-%M")

#GERA LOG DA CLASSES
/apps/jdk1.8.0/bin/./jmap -histo $PID > class_histogram_$NOW.log

Orientação a objetos, você conhece bem?

Programadores hoje tendem a se maravilhar muito com as tecnologias que estão na modinha, mas não se preocupam em aprender e solidificar o conhecimento no básico, em escrever código bem feito, testável e de fácil reuso. Irei apresentar vários conceitos nesse artigo que serão atualizados de acordo com o meu tempo disponível.

SOLID é um acrônimo para os principais conceitos que todo programador deveria conhecer para não fazer "cagadas" no código fonte.

S - Single responsibility principle
Uma classe deveria ter apenas uma responsabilidade. Classes com uma única responsabilidade são mais fáceis de racionar sobre, mais fáceis de testar, mais fáceis de serem reutilizadas e mais fáceis para se realizarem manutenção pois ela irão modificar por apenas um motivo.

O - Open/closed principle
Uma classe deveria ser aberta para extensões e fechada para modificações. Quer dizer que podemos modificar um comportamento de uma classe sem mexer em uma única linha de código fonte, e como faríamos isso? Utilizando abstrações ao invés de implementações.

L - Liskov substitution principle 
Uma classe poderia ser substituída por outra classe sem gerar um comportamento inesperado. Principio mais utilizado quando estamos usando herança, e uma classe filha sobrescreve um método na classe pai e lança uma exceção por exemplo.

I - Interface segregation principle 
Assim como uma classe deveria ser coesa, interfaces também devem se atentar a coesão. Interface com muitos métodos que trazem muitas responsabilidades as classes, faz com que o princípio "Single Responsability Principle" quebrar.

D - Dependency inversion principle 
Uma classe deveria depender de abstrações ao invés de implementações. Isso está bem relacionado com o Open/closed principle, onde uma classe deveria ser aberta para extensões. Abstrações tendem a ser mais estáveis do que implementações, por isso a ideia seria receber através do construtor dessa classe uma abstração, essa abstração poderá transformar completamente o comportamento da classe sem alterar nenhuma linha de código. Outra questão importante é nunca instanciar as implementações dentro da classe e sim sempre recebe-las através do construtor.

Artigo terá mais atualizações.

Mais informações:
SOLID - Wikipedia
Functional programming is cool, but you know OO ? (Vídeo)

Instalando MongoDB no Windows

Bom a instalação do mongodb no windows não tem segredo, siga os passos abaixo:

1. Faça o download do zip em https://www.mongodb.org/downloads
2. Descompacte e coloque em uma pasta da sua escolha
3. Adicione no PATH do windows o caminho do MongoDB, caso você já saiba fazer isto, pule para o passo 5.
4. Adicionando variável no PATH do windows é simples, clique com o botão direito em Meu Computador, e entre na opção “Propriedades”. Abra a guia “Avançado”. Clique no botão “Variáveis de Ambiente”. Na lista que aparecerá abaixo (Variáveis do Sistema), procure pela variável de “Path”, selecione-a e clique em editar. Ai é só adicionar o caminho completo da sua pasta mongodb. O meu ficou assim:
   C:\Program Files\Intel\WiFi\bin\;C:\Program Files\Common Files\Intel\WirelessCommon\;C:\tools\mongodb\bin;
   Perceba que não é para excluir o que já existe, apenas adicionar ao final da linha o caminho completo da pasta mais o \bin
5. Depois de ter feito isso é interessante adicionar o MongoDB como serviço, para que ao iniciar o Windows o MongoDB já seja iniciado junto. Para isso execute a seguinte linha no Terminal (Command Prompt) como administrador:
   mongod --dbpath=C:\tools\mongodb\db\data --logpath=C:\tools\mongodb\db\data\log.txt --install
   Onde dbpath é o caminho do banco de dados e logpath é o caminho do log.
6. Pronto, agora é só digitar mongo no terminal e começar a usar o MongoDB