Happy Hour #3 - Can you RUN it

Fala galera que segue o blog...

Nesse post de Happy Hour de hoje eu vou estar falando sobre o "Can You Run it?", que é um serviço online que analisa seu computador verificando se o mesmo possui os requisitos necessários para rodar os vários jogos disponíveis no mercado.

Se você é um fã de jogos e usa o computador para jogar, sabe o quanto é foda chato, baixar comprar um jogo instalar, configurar e descobriu que sua máquina não possui o mínimo necessário parar rodar. Agora nas férias é hora de testar novos jogos *-*

Jovem chato: "Ahh, mas no CD fala os requisitos mínimos para o jogo rodar".

Sim, existem casos que a diferença é grande ai não adianta jovem, vai perder tempo, dinheiro no jogo. Mas temos que pensar que muitas vezes são crianças que querem instalar o jogo e não entende muito de configuração (RAM, processador, placa de vídeo....) e em outros casos sabe-se que não possui o necessário e gostaria de saber onde será necessário o upgrade na máquina para ser possível rodar o jogo.

Por isso, o serviço auxilia e muito nessa hora.

Bom, mas como realizar essa verificação?

Caso você esteja utilizando o serviço pela primeira vez será necessário instalar um client na sua máquina para que o site possa capturar as informações necessárias para a análise da sua máquina.

A forma mais simples é acessar o site, pesquise por um jogo clique em "CAN YOU RUN IT". Um pop-up será apresentado pedindo que selecione entre baixar o client mencionado ou apenas apresentar os requisitos necessários do jogo, essa opção não fará uma análise da sua máquina, apenas informara os requisitos mínimos e o recomendado.

Selecione a primeira opção, aguarde o download finalizar, execute o arquivo, aguarde enquanto o programa realiza as buscas necessárias de software e hardware da sua máquina, volte no navegador e aguarde que o navegador detecte que o client foi instalado e pronto.

Pesquise pelos jogos do seu interesse e receba um relatório detalhado se sua máquina possui o minimo necessário ou possui o recomendado.

O CYRI NÃO DEVE SER ADOTADO COMO ÚLTIM PALAVRA PARA INSTALAR OS JOGOS. É UTILIZADA PARA TER UMA NOÇÃO DOS HARDWARES/SOFTWARE NECESSÁRIOS.

É isso ai pessoal, bom jogo! 

Diferença entre String, StringBuilder e StringBuffer em Java #3

Dando continuidade na sequência de posts sobre "Diferença entre String, StringBuilder e StringBuffer", hoje vamos comparar a velocidade de processamento entre StringBuilder e StringBuffer. Sugiro dar uma olhada nos post anteriores, caso ainda não tenha visto, clicando aqui.

StringBuilder e StringBuffer são muito rápidos para concatenação de Strings comum e exercem a mesma função, com a principal diferença que, enquanto o StringBuffer é sincronizado, o StringBuilder não!
Imagine várias threads lendo ou alterando a mesma String, e você precisa manter a consistência do do seu código, para esses casos o ideal é utilizar StringBuffer.

No teste a seguir você vai perceber que StringBuilder é mais rápido do que o StringBuffer. Veja o código abaixo:

• Comparando performance de StringBuilder e StringBuffer

public class ConcatenaString {

    public static void main(String[] args) { 
              
        // Trecho de código para StringBuffer
        StringBuffer strBuffer = new StringBuffer();
        long tStart = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            strBuffer.append("f");
        }

        long tEnd = System.currentTimeMillis();
        long tResult = tEnd - tStart;
        System.out.println("Tempo de execução com StringBuffer = " + tResult + " ms"); 
        
        // Trecho de código para StringBuilder
        StringBuilder strBuilder = new StringBuilder();
        tStart = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            strBuilder.append("f");
        }

        tEnd = System.currentTimeMillis();
        tResult = tEnd - tStart;
        System.out.println("Tempo de execução com StringBuilder = " + tResult + " ms");
    }
}

Tempo de execução com StringBuffer = 5 ms
Tempo de execução com StringBuilder = 3 ms

Muito bem, vimos os problemas em usar String para concatenar utilizando o operador "+", as possíveis soluções para evitar problemas de processamento, vimos a principal diferença entre StringBuilder e StringBuffer, mas e aí? Quando eu devo utilizar o operador "+" para concatenar Strings? Existem situações em que o operador "+" é utilizado, e são aqueles onde queremos manter a qualidade do código em relação a identação, para facilitar a legibilidade do código, sem a necessidade de criar um novo objeto, que também é conhecido como "mult-line Strings".
Veja o código:

public class ConcatenaString {

    public static void main(String[] args) {

        /**
         * Apenas melhorando a legibilidade, sem criar novos objetos
        */
        String strFinal = "Pessoal "
                            + "seja bem vindo "
                            + "ao blog "
                            + "DevIsComing!";

        /**
         * Outro exemplo de uso sem compromoter o desempenho
        */
        int a = 5;
        int b = 15;
        System.out.println("a é igual=" + a + " e b é igual=" + b + " certo!?");
    }
}

Pessoal acabamos por aqui.
Até a próxima!

O que é uma CDN?

CDN (Content Delivery Network) é uma rede de distribuição de informação que permite fornecer conteúdo Web de uma forma mais rápida a um grande número de utilizadores, distribuindo o conteúdo por múltiplos servidores.

Essa explicação é simples e objetiva e também fácil de encontrar em qualquer canto da internet.

Mas eu gostaria de explicar minuciosamente o que é na verdade a CDN, e como ela "controla a internet que você usa".

Imagine por exemplo que a empresa DEVIC (Developer is Coming rs) libera uma atualização para um software e o servidor onde essa atualização está hospedada encontra-se na América. Até aqui tudo normal.

Agora imagine que para esse sistema temos vários usuários pelo mundo todo, e que a Europa é o principal usuário desse software, também precisa fazer o download dessa atualização. Dessa forma torna-se muito mais cômodo utilizar uma rede de distribuição de conteúdo com servidores localizados em vários pontos do mundo para permitir que os usuários Europeus tenham um acesso mais rápido a atualização.

Outro cenário: sua empresa cresceu muito, você exporta para a China, porém seu site em mandarim leva 40 segundos para ser exibido em Pequim. Você atende do sul ao norte mas a qualidade só é aceitável no sudeste. Sua empresa exporta para a Ásia, mas seu site só pode ser visto nas Américas.

E por último: quantos usuários eu espero para datas comemorativas, como dia das Mães e o Natal? Onde segundo pesquisas são os melhores períodos de venda.

Como prever a demanda?

Para suportar essa demanda eventual a infraestrutura do seu serviço precisa estar muito bem balanceada, mas o que devo considerar a mediana de acessos? a maior demanda?

Todo esse drama chega ao fim. Tudo está resolvido, e o aplicativo é um sucesso.

A proposta da rede distribuída de CDN é resolver todas os pontos citados de maneira, simples e elegante, sem que tenhamos alem dos problemas de desenvolvimento e infraestrutura que nos preocupar com o que não está no nosso controle: a internet.

Para o exemplo da atualização com clientes espalhados pelo mundo, teríamos o mesmo arquivo de atualização espalhados por vários servidores de forma que casa usuário possa acessar a atualização nos servidores mais próximos, onde um usuário Francês tenha o conteúdo ofertado por servidores na França, o usuário brasileiro recebe seu conteúdo também regionalizado. Isso significa:

• ausência de infraestrutura própria para disponibilizar o conteúdo;
• menor latência e maior banda para download.

Uma das primeiras e mais básicas funcionalidades da CDN é cachear o conteúdo para o usuário final, o mais próximo possível dele.

E para as datas comemorativas, como a CDN pode nos auxiliar?

O servidores onde estão hospedados os serviços, ficam responsáveis por subir máquinas ou desligar máquina, dessa forma você nunca terá máquinas ociosas, gastando uma fortunas para mante-las no ar, quando na verdade não está sendo necessário.

Ou seja, quando seu serviço tiver uma demanda baixa, poucas máquinas estarão ligadas disponibilizando serviço, quando a demanda aumenta, as máquinas passam a funcionar para suportar a quantidade de acessos.

Hoje a maior CDN do mundo é a Akamai e possui mais de 130mil servidores, reunindo vários nomes fortes do mundo da tecnologia em sua lista de clientes. Essa mesma rede suporta em dias normais 6Tb/seg de tráfego. Aproximadamente 30% de toda a internet mundial.

Até a próxima!

Diferença entre String, StringBuilder e StringBuffer em Java #2

Esse é o segundo post sobre "Diferença entre String, StringBuilder e StringBuffer em Java", caso tenha perdido o primeiro post clique aqui para acompanhar o assunto.

Anteriormente aviamos avaliado o desempenho quando concatenamos vários caracteres "f", utilizando String. Podemos concluir que utilizar String para concatenar strings pode ser muito prejudicial para o desempenho do seu código.

Hoje vamos analisar a diferença do tempo de processamento entre String e StringBuilder.

Para facilitar, vamos utilizar o mesmo código anterior, realizando pequenas adaptações, para vermos de fato a velocidade de execução do StringBuilder

• Comparando performance de String e String Builder

public class ConcatenaString {

    public static void main(String[] args) { 
              
        // Trecho de código para String
        String strFinal = "";
        long tStart = System.currentTimeMillis(); 
        
        // Vamos concatenar 100000 vezes o caractere 'f', 
        // então relembremos que cada vez que passarmos no laço 
        // a JVM irá criar um novo objeto em memória.
        for (int i = 0; i < 100000; i++) {
            strFinal += "f";
        }

        long tEnd = System.currentTimeMillis();
        long tResult = tEnd - tStart;
        System.out.println("Tempo de execução com String = " + tResult + " ms"); 
        
        // Trecho de código para StringBuilder
        StringBuilder strBuilder = new StringBuilder();
        tStart = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            strBuilder.append("f");
        }

        tEnd = System.currentTimeMillis();
        tResult = tEnd - tStart;
        System.out.println("Tempo de execução com StringBuilder = " + tResult + " ms");
    }
}

Tempo de execução com String = 14627 ms
Tempo de execução com StringBuilder = 0 ms

Na minha máquina ao executar o código acima, a saída foi de 14627ms para String com o operador "+" e 0ms para o StringBuilder. Foram utilizados apenas 100mil caracteres, mas vamos imaginar se aumentássemos em 10x esse valor... Seria 1milhão de caracteres.

Altere o valor do seu código e verifique a o tempo de processamento.

Perceba que para não tornar o teste tendencioso, coloquei o tInicio e o tFim no início e no fim do laço "for", dessa forma desconsideramos qualquer outro código que venha antes ou depois, por exemplo as atribuições e escritas no console, assim avaliamos puramente a concatenação de ambos.

Sem dúvidas a performance do StringBuilder comparado a String comum é muito melhor quando precisamos concatenar valores.

O que acontece na verdade é que StringBuilder é mútavel, ou seja, a cada "append(valor)" que fizemos no laço, concatenamos de fato um novo valor a String já existente, sem a necessidade da criação de um novo objeto em memória. Mas e qual a diferença entre StringBuilder e StringBuffer? A resposta fica para o próximo post. Até a próxima.

Diferença entre String, StringBuilder e StringBuffer em Java #1

Nesse post irei explicar a diferença entre String, StringBuilder e StringBuffer.

Ainda existem dúvidas sobre o real motivo da existência desses tipos, por isso vou explicar e assim você será capaz de julgar com eficácia qual será usado em um momento adequado.

Em java todos os tipos utilizados, exceto os tipos primitivos (boolean, int, char e double), são "objetos". Ao contrário do que acontece em C e C++, string em Java não são tratados como sequência de caracteres terminadas por NULL. São objetos ou instâncias da classe java.lang.String, por isso devem ser declarados e instanciados.

EXEMPLO

Quando estamos codificando, as vezes é necessário concatenar strings, e usamos o operador "+" para faze-lo. No entanto o uso com frequência desse operador na sua aplicação lhe trará problemas assim você passará a dar mais importância ao uso do StringBuilder e StringBuffer.

Certamente já ouviram em algum lugar que "String são imutáveis", ou seja, você não pode mudar seu valor após a primeira atribuição. Mas, se strings são imutáveis como eu consigo concatenar vários valores a uma String, modificando-a para que se torne diferente da original?

O que acontece na verdade é que você não está concatenando nada, mas sim, criando um novo objeto em memória. Cada vez que você concatena (ou acha que esta concatenando) uma String com outra, você esta na verdade criando diversos objetos distindos em memória, e as Strings primárias perdem a referência, mas ainda não deixaram de existir, continuam lá. Vamos analisar esse exemplo parar ver o que acontece.

• Concatenação simples se String

public class ConcatenarString {
 public static void main (String[] args){ 
  // Criamos uma string e atribuimos um valor
  
  String str = "Hello"; 
  
  // Nossa string passará a ser: "Hello World".
  // No entanto a string "World" foi criada em memória,
  // Após a 'concatenação' a JVM cria um outro objeto "Hello World".
  // Totalizando 3 objetos para que essa 'concatenação' ocorra.
  
  str.concat(" World"); 
  
  // O mesmo conceito é aplicado aqui.
  // É criada uma string "from Java" em memória, depois é criada uma
  // nova juntando "Hello World from Java".
  // No total temos agora 5 objetos em memória,
  // sendo que estamos utilizando apenas 1,
  // veja que desperdício.  
  
  str += " from Java";
 }
}

E se isso ainda não te convenceu que usar a concatenação dessa forma é muito prejudicial a performance da aplicação, vamos verificar o seguinte teste.

• Concatenar 35536 vezes o literal "f"

public class ConcatenarString {
    public static void main(String[] args) {
        String strFinal = "";

        // Vamos concatenar 65536 vezes o caracter 'f', 
        // então entenda que cada vez que passarmos no laço 
        // a JVM irá criar um novo objeto em memória.
        for (int i = 0; i < 65536; i++) {
            strFinal += "f";
        }
    }
}

Veja quanto tempo demora para executar o código acima na sua máquina. Na minha máquina o tempo foi de 7 segundos.

Vou parando por aqui... enquanto aguarda a continuação desse post, realize novos testes alterando a quantidade de caracteres e verifique como fica o desempenho da sua máquina para processar o código.

Até mais, abraços!