agendar rapidamente um comando

echo '<<command>>' | at <<horario>>

echo 'init 0' | at 1:00 am

Complexidade ciclomática

Complexidade ciclomática (ou complexidade condicional) é uma métrica de software usada para indicar a complexidade de um programa de computador. Desenvolvida por Thomas J. McCabe em 1976, ela mede a quantidade de caminhos de execução independentes a partir de um código fonte.

Essa complexidade é computada através do grafo de fluxo de controle do programa: os nós do grafo correspondem a grupos indivisíveis de comandos, e uma aresta direcionada conecta dois nós se o segundo comando pode ser executado imediatamente após o primeiro. A complexidade ciclomática também pode ser aplicada a funções, módulos, métodos ou classes individuais dum programa.

Uma estratégia de teste de software formulada por McCabe é testar cada caminho independente dum programa, de forma que a quantidade de casos de teste será a complexidade ciclomática do programa.

A complexidade ciclomática de uma seção do código fonte é a quantidade de caminhos independentes pelo código. Por exemplo, se o código fonte não contém estruturas de controle senão sequenciais a complexidade é 1, já que há somente um caminho válido através do código. Se o código possui somente uma estrutura de seleção contendo somente uma condição, então há dois caminhos possíveis, aquele quando a condição é avaliada em verdadeiro, e aquele quando a condição é avaliada em falso.

Matematicamente, a complexidade ciclomática de um programa estruturado é definida com referência ao grafo direcionado que contém os blocos básicos do programa, com uma aresta entre dois blocos se o controle pode passar do primeiro para o segundo imediatamente, sem blocos intermediários. A complexidade então é definida como:

Em que:

•  – complexidade ciclomática
•  – quantidade de setas
•  – quantidade de nós
•  – quantidade de componentes conectados

Uma formulação alternativa é usar um grafo em que o ponto de saída é conectado ao ponto de entrada. Nesse caso, o grafo é dito fortemente conectado, e a complexidade ciclomática do programa é equivalente ao número ciclomático do grafo, definido como:

Isso pode ser visto como o cálculo da quantidade de ciclos independentes que existem no grafo, isto é, os ciclos que não contém outros ciclos embarcados. Notar que, tendo em vista que o ponto de saída é conectado ao ponto de entrada, há pelo menos um ciclo para cada ponto de saída.

Para um programa único, ou subrotina ou método, P é sempre igual a 1. Entretanto, a complexidade ciclomática pode ser aplicada a diversos programas ou subprogramas simultaneamente, de forma que P será a quantidade de programas em questão. Pode-se demonstrar que a complexidade ciclomática de qualquer programa estruturado com somente um ponto de entrada e um ponto de saída é igual a quantidade de pontos de decisão – como condicionais de estruturas de seleção ou uma iteração dos laços das estruturas de repetição – mais um.

A complexidade ciclomática também pode ser estendida para programas com múltiplas saídas, definida como:

Em que:

•  – quantidade de pontos de decisão do programa
•  – quantidade de pontos de saída

Fonte: http://pt.wikipedia.org/wiki/Complexidade_ciclom%C3%A1tica

Criando Scheduled com spring

Anotar a Classe com
@Component
=========================================================
Anotar o método com
@Scheduled(cron = "* * 0 * * ?")
cron = segundos, minutos, hora, dia, mês

cron = "* * 0 * * ?" -> meia noite
cron = "*/5 * * * * ?" -> a cada 5 segundos
cron = "* 2/5 * * * ?" -> apartir do segundo minuto a cada 5 minutos
cron = "5 30 5 * * ?" -> 5:30:05 AM
=========================================================
Incluir no context do spring



<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
       http://www.springframework.org/schema/task
       http://www.springframework.org/schema/task/spring-task-3.0.xsd"
>

<task:annotation-driven/>
...
</beans>
========================================================

Fonte: http://howtodoinjava.com/2013/04/23/4-ways-to-schedule-tasks-in-spring-3-scheduled-example/

Import xml do excel em java com Xstream

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package teste.xml.excel;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.mapper.MapperWrapper;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.List;

/**
 *
 * @author smart
 */
public class Teste {

    public static void main(String[] args) throws IOException, Exception {

        Teste t = new Teste();
        XStream xstream = t.getXStream();
        xstream.setMode(XStream.NO_REFERENCES);

        xstream.alias("Workbook", Teste.Workbook.class);
        xstream.addImplicitArray(Teste.Workbook.class, "Worksheet", Teste.Worksheet.class);
        xstream.alias("Table", Teste.Table.class);
        xstream.addImplicitArray(Teste.Table.class, "Row", Teste.Row.class);
        xstream.addImplicitArray(Teste.Row.class, "Cell", Teste.Cell.class);
        xstream.alias("Cell", Teste.Cell.class);
        xstream.alias("Data", String.class);

        Teste.Workbook o = (Teste.Workbook) xstream.fromXML(new File("/home/smart/NetBeansProjects/Teste Rest/build/classes/teste/xml/excel/excel.xml"), new Teste.Workbook());
        System.out.println(o);
    }

    public XStream getXStream() {
        XStream xstream = new XStream() {

            @Override
            protected MapperWrapper wrapMapper(MapperWrapper next) {
                return new MapperWrapper(next) {

                    @Override
                    public boolean shouldSerializeMember(Class definedIn, String fieldName) {
                        if (definedIn == Object.class) {
                            return false;
                        }
                        return super.shouldSerializeMember(definedIn, fieldName);
                    }
                };
            }
        };

        return xstream;
    }
 
    private String getURIArquivo(String arquivo) throws Exception {
       URL is = this.getClass().getResource(arquivo);
       if (is == null) {
           is = this.getClass().getClassLoader().getResource(arquivo);
       }
       return URLDecoder.decode(is.toString(), "UTF-8");
   }

    static class Workbook {

        private List<Worksheet> Worksheet;

        public List getWorksheet() {
            return Worksheet;
        }

        public void setWorksheet(List Worksheet) {
            this.Worksheet = Worksheet;
        }
    }

    static class Worksheet {

        private Teste.Table Table;

        public Teste.Table getTable() {
            return Table;
        }

        public void setTable(Teste.Table Table) {
            this.Table = Table;
        }
    }

    static class Table {

        private List<Row> Row;

        public List getRow() {
            return Row;
        }

        public void setRow(List Row) {
            this.Row = Row;
        }
    }

    static class Row {

        private List<Cell> Cell;

        public List getCell() {
            return Cell;
        }

        public void setCell(List Cell) {
            this.Cell = Cell;
        }
    }

    static class Cell {

        private String Data;

        public String getData() {
            return Data;
        }

        public void setData(String Data) {
            this.Data = Data;
        }
    }
}

Gerador de configuração para balanceamento de carga

fonte: http://lbconfig.appspot.com/

Por que as letras do teclados não estão em ordem alfabética?

QWERTY é o layout de teclados atualmente mais utilizado em computadores e máquinas de escrever. O nome vem das primeiras 6 letras “QWERTY”.

A disposição das teclas foi patenteada por Christopher Sholes em 1868 e vendido à Remington em 1873, quando foi visto pela primeira vez em máquinas de escrever. Nota: Qwerty Uiop, seqüência de letras da primeira fileira, às vezes é confundido com o inventor, mas isso não passa de um mito.

Nesse layout, os pares de letras utilizados com maior frequência na língua inglesa foram separados em metades opostas do teclado, numa tentativa de evitar o travamento do mecanismo das rudimentares máquinas do século XIX. Ao alternar o uso das teclas, o arranjo evitava o travamento de teclas nas antigas máquinas de escrever: enquanto uma mão acerta uma tecla, a outra localiza a tecla seguinte.

Outros padrões foram propostos, como o Dvorak (imagem a baixo), mas nunca atingiram a mesma popularidade do QWERTY.

O layout QWERTY é adotado com alterações em algumas línguas formando os teclados AZERTY e o QWERTZ, em que as letras Y e Z estão trocadas. Símbolos, diacríticos e caracteres acentuados estão em posições diferentes nas variações internacionais do QWERTY.

Curiosamente, a palavra “typewriter” (máquina de escrever, em inglês) pode ser escrita utilizando-se apenas as letras contidas na linha superior do teclado (QWERTYUIOP).

Fonte: http://minilua.com/que-letras-teclados-nao-estao-ordem-alfabetica/

Limpar conteúdo de componentes jsf

/**
 * Limpa os dados dos componentes de edição e de seus filhos,
 * recursivamente. Checa se o componente é instância de 
 * EditableValueHolder e 'reinicia' suas propriedades.
 */
public void cleanSubmittedValues(UIComponent component) {
    if (component instanceof EditableValueHolder) {
        EditableValueHolder evh = (EditableValueHolder) component;
            evh.setSubmittedValue(null);
            evh.setValue(null);
            evh.setLocalValueSet(false);
            evh.setValid(true);
        }
        if(component.getChildCount()>0){
            for (UIComponent child : component.getChildren()) {
                cleanSubmittedValues(child);
            }
        }
    }
}

Fonte: https://github.com/rponte/jsf-loja-project/blob/master/src/br/com/triadworks/loja/util/FacesUtils.java#L58