Automalab

Um amigo meu Dalasiel, mostrou em na Jornada do Maranhão um projeto muito interessante que está saindo como resultado da sua iniciação científica. O nome do projeto é Automalab, e se destina a ser um auxílio nas medições de laboratórios de física, para diminuição dos erros nos experimentos. Segue um texto abaixo explicando o software:

 

AUTOMALAB UM SISTEMA COMPUTACIONAL DESENVOLVIDO EM UMA LINGUAGEM DE PROGRAMAÇÃO ORIENTADA A OBJETOS PARA AQUISIÇÃO, PROCESSAMENTO E ANÁLISE DE DADOS EM LABORATÓRIO DE ENSINO DE FÍSICA EXPERIMENTAL II

Descrição: O uso do computador como ferramenta tornou-se uma prática não apenas fundamental no processo de ensino-aprendizagem, mas uma questão de sobrevivência do próprio processo. Com esta pesquisa o CEFET visa dispor de um sistema computacional de aquisição de dados e processamento destes em planilhas para análises gráfica e numérica de experiências em laboratório de Física. Este projeto visa capacitar alunos em uma linguagem de programação moderna, orientada a objetos, permitindo o desenvolvimento de projetos utilizando GUIs (Graphics User Interfaces) apropriadas para entrada e saída dos dados experimentais a serem analisados [DEITEL e DEITEL, 2005; TEMPLEMAN e OLSEN, 2003]. Além disso, o sistema computacional aqui denominado AUTOMALAB tem o objetivo de controlar sensores de aquisição e processamento de medidas comuns em Eletromagnetismo[MPLAB, 2007]. .

CONNEPI

Nesse momento estou escrevendo um post de João Pessoa, onde estou participando de (mais) um evento do CEFET-PE, o CONNEPI (II Congresso de Pesquisa e Inovação da Rede Norte Nordeste de Educação Tecnológica) que é um dos eventos de troca de informações entre os cefets do norte nordeste sobre as pesquisas e projetos de extensão que estão em desenvolvimento.

Conseguimos aqui aprovar o carrossel de cores, que foi um trabalho feito em sala de aula, e que evoluiu de forma interessante. Já é o segundo evento que conseguimos submeter e conseguir a aprovação do trabalho! O último que ainda resta tentar é um congresso no rio de Janeiro (isso ainda tem um longo período de espera…)

O Congresso tah andando bem,  mas é complicado pois tem trabalhos demais e de muitas áreas.  Não é somente um evento de informática, mas um evento de todas as áreas de pesquisa e extensão dos CEFETs (futuramente IFETs), o que torna o evento bem inchado, mas com uma possibilidade imensa de troca de experiências com outras disciplinas e com pessoas que trabalham em projetos próximos dos nossos.

Nos trabalhos das pessoas, tem Transformadas de Wavelets, Rede de sensores sem fio, um paranóico que acha que pode monitorar o momento em que ele leva uma gaia com um detector de movimento com alertas via SMS,  trabalhos de conscientização ambiental do uso de agrotóxicos, segurança em ambientes de radiologia e radioterapia… Muito trabalho legal desenvolvido pelos cursos superiores e técnicos dos cefets.

Meu trabalho será apresentado amanhã. O projeto do carrossel de cores é aberto, código livre e quem se interessar por continuar seu desenvolvimento, com novos features, bug fixes, explicações sobre como e onde usar bem, está mais que convidado a enviar e-mail pra mim e a visitar a página do projeto aqui.

Google’s Android Developer Challenge

Acrescentando mais uma à lista de competições de desenvolvimento, o google chega logo após o anúncio da plataforma Android para celulares.

Esta competição se destaca por somar seus prêmios em nada menos que R$ 10 Milhões. Tudo que se tem a fazer, é juntar um time (ou ter vontade de fazer sozinho mesmo) baixar o SDK, (que já vem com emulador) o plugin do eclipse e começar a programar.

Tema? Direcionamento? Faça algo legal e concorra, só isso! Maiores informações, veja o link

Até confesso que deu vontade de concorrer depois que vi um tutorial sobre o SDK. Bem interessante!

Padrões de Projeto 1: Singleton

Hoje as coisas estão um bocado apertadas, mas se esse post não sai hj, não sei quando sai. Foi uma semana de muito trabalho, muita burocacia (pra me inscrever no mestrado) e agora que consegui a inscrição, tenho logo de colocar esse post q já estava esperando por ser publicado a uma semana!

Singleton é um padrão de criação bem simples, e o problema endereçado é o de criar uma única instância de uma classe. Isso pode ser uma necessidade para garantir desempenho do sistema (não criando objetos demais que poderiam ser reaproveitados em outros momentos), uma exigência de usabilidade de tela ou mesmo uma regra de negócio.

Há uma discussão interessante em [1] e [2] sobre os problemas de singleton como um padrão de projeto. O fato ocorre pois (como você vai ver mais a frente) o singleton utiliza de recursos de implementação que não são considerados boas práticas de POO, além de também ser considerado prejudicial para a organização da arquitetura da aplicação se usado exageradamente.

Em C++:

class MyClass{
	private:
		MyClass() {}
 	public:
		static MyClass* getInstance()
       		{
			static MyClass *instance = 0;
			return instance ? instance : (instance = new MyClass());
		}
};

Em Java:

 public class MyClass{
	private MyClass instance = null;
 	private MyClass(){
	}

	public static MyClass getInstance(){
 		if (instance == null){
			instance = new MyClass();
		}
		return instance;
	}
}

[1] Perils of the Singleton – http://www.softwarereality.com/design/singleton.jsp

[2] The One: A Singleton Discussion – http://www.gamedev.net/reference/articles/article1825.asp

[3] Problems with design pattern “Singleton” – http://www.theserverside.com/blogs/thread.tss?thread_id=41546

[4]Singleton Pattern #3: Problems with Singleton, Thread-Safe Singleton Class – http://www.kamalmeet.com/wordpress/2007/02/15/singleton-pattern-3-problems-with-singleton-thread-safe-singleton-class/

Palestra no CEFET-PE

É! Mais um fruto da iniciação científica! Hoje palestrei no auditório do Cefet-PE, “Uma Introdução à Mineração de Dados”, que foi um resumão das minhas pesquisas pro PIBIC em mineração de dados. Foi bem legal, lá estavam outros ex-bolsistas do CEFET assistindo, e também os alunos de Eletrotécnica, que foram lá ver o que danado era isso. Bem, os slides estão aqui.

Padrões de Projeto 0: Introdução

Desenvolver software é algo complicado. É necessário compreender de tecnologia , do negócio do cliente, e ainda ser ajuizado o suficiente para manter todo o conhecimento ali produzido documentado da melhor maneira possível, para que outros possam continuar o projeto.

Uma das formas de documentação do conhecimento produzido em um processo de desenvolvimento de software que surgiu naturalmente como iniciativa comunitária, foram os padrões de projeto. E o que são padrões de projeto? Existem algumas definições as quais podemos recorrer:

Def. 1: (GoF) Um padrão de projeto sistematicamente nomeia, motiva e explica um projeto genérico, que endereça um problema de projeto recorrente em sistemas orientados a objetos. Ele descreve o problema, a solução, quando é aplicável e quais as conseqüências do seu uso.

Def.2: (Coplien) Um padrão (de projeto) é uma peça de literatura que descreve um problema de projeto e a solução geral para o problema em um contexto particular.

Def.3: (Budinsky, Finnie, Vlissides e Yu) Padrões de projeto capturam a experiência na construção de software orientado a objetos.

Budisky et al. põem uma importância enorme aos padrões de projeto na sua definição. Capturar a experiência é algo naturalmente difícil e extremamente útil.

Mas, como surgiram os padrões de projetos para a computação? Isso nos leva ao ano de 1987, quando Ward Cunninghan e Kent Beck propuseram (implementados em Smalltalk) os primeiros 5 padrões e os apresentaram na OOPSLA. Num trabalho paralelo a sua tese de doutorado, Eric Gamma nota a importância dos padrões repetitivos em projetos, levando o tema a discussão em conferência integrada da OOPSLA e ECOOP em 1990, junstamente com Bruce Anderson e Richard Helm. A partir de então, o tema ganha mais importância, com a prublicação de livros como “Advanced C++ Programming Styles and Idioms” (Coplien, 1992), ou “Design Patterns: Elements of reusable object-oriented software” da gangue dos quatro (1995) e vários outros.

Existem alguns critérios para que uma solução torne-se um padrão:

1. Devem descrever e justificar as soluções para problemas concretos e bem definido, i.e., não são estratégias ou princípios de implementação;
2. As soluções descritas devem estar comprovadas, i.e., devem ter sido previamente experimentadas e testadas;
3. O problema tratado por um padrão deve ocorrer em diferentes contextos, ou seja, se a solução não tem aplicação em diferentes situações, então não é um padrão;
4. Usualmente os padrões de projeto descrevem relações entre os conceitos, mecanismos e estruturas existentes nos sistemas;
5. Os padrões de projeto devem ser capazes de capturar a evolução e o aprimoramento das soluções, assim como equilibrar os pontos fortes e fracos encontrados, sendo assim, não são soluções óbvias ou triviais;
6. Os padrões devem ser utilizados em conjunto com outros padrões, compondo uma linguagem de padrões.

Podemos dividir os padrões em três categorias:

• Padrões de Criação: Ligados ao processo de instanciação;
• Padrões Estruturais: Observam as formas de composição dos objetos e/ou classes;
• Padrões Comportamentais: Observam a maneira com que classes e objetos podem interagir.

O que vou fazer aqui é descrever e comentar um pouco sobre os padrões que conheço e/ou mais populares, acrescentando códigos em Java (talvez em C++) para ilustrar a utilização.

É importante notar que os padrões não são o grande canivete suíço que resolverá todos os seus problemas, mas constituem uma ferramenta extra muito útil nas situações do dia-a-dia, e certamente facilitará a vida de quem os conhece.

À medida que for comentando os padrões, colocarei seus links neste artigo, que servirá como índice e introdução ao tema.

Singleton

JVM Power Boost!

Vou agora propôr uma brincadeira com quem ler este post.

Quem consegue abrir e fechar mais prompts de comando do windows, usando java? Use o seguinte código:

public static void main (){
    ArrayList<Process> cmdProcess = new ArrayList<Process>();
    // Abrindo os processos:
    for(int i=0; i < 100000; i++){
        cmdProcess.add(Runtime.getRuntime().exec("cmd.exe"));
        System.out.println("Quantidade de Processos abertos: "+ i );
    }
    // Fechando os processos:
    for(Process p: cmdProcess){
        p.destroy();
    }
}

Eu consegui na minha máquina do trabalho, 3964 processos abertos até o computador estilar e parar tudo. Quanto será que a sua máquina consegue?

Agora, é possível obter muito mais. Quando for iniciar o programa, ao invés de usar a JVM com as opções padrão, use as opções: -XX:+AggressiveOpts -XX:+AggressiveHeap

Aqui, isso conseguiu rodar o programa sem problemas, o que significa que eu conseguiria abrir mais de 10000 processos, que já é bem mais próximo do limite do Windows XP (~22000)

então, mãos à obra!!

Saiu Netbeans 6.0 Beta1

Enfim, saiu o NetBeans 6.0 Beta1 (mais perto que longe do lancamento mesmo =P)

Bem… sou ex-usuário eclipse, e confesso e esta versão 6 está muito boa.

http://www.netbeans.org/servlets/NewsItemView?newsItemID=1109

Atalhos no netbeans

4 Atalhos importantíssimos pra ir mais rápido no NetBeans 6.0:

• Alt+Shift+F

Formata (Identa) o código

• Alt + Insert

Geração rápida de código (getters, setters, equals, hashCode…)

• Ctrl + Shift + I

Correção dos Imports

• Code Templates!

Essa é muito boa, e no netbeans 5.5. eu tinha trabalho em fazer funcionar. Basta digitar a palavra chave e pressionar Tab. Bons e úteis code templates:

1. fore -> laço for extendido
2. psvm -> cria um método main (public static void main)
3. sout -> System.out.println(“”);
4. serr -> System.err.println(“”);

É possível ver todos os existentes e ainda construir novos code templates seguindo o menu Tools > Options > Editor > Code Templates.

GTalk no Java!!!

Estudando a viabilidade de inserir um IM em um projeto, fui procurar bibliotecas para XMPP (Jabber) em Java. Como o GTalk usa o protocolo XMPP, então meu esperimento era implementar um programinha que recuperasse a lista de usuários de um usuário do GTalk, para mostrar se era fácil de mexer nisso.

Como resultado da procura, encontrei a Smack API. É uma biblioteca que implementa o XMPP em java, inclusive sem ter de tratar as coisas no baixo nível. Existem classes para abstração de Chat, e muito mais.

O código segue abaixo:

/*
 * ListUsers.java
 *
 * Created on 22 de Junho de 2007, 12:52
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package br.cefetpe.chat.gui;

import java.util.Collection;
import java.util.Scanner;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.Roster;
import org.jivesoftware.smack.RosterEntry;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.Presence;

/**
 *
 * @author LENDES
 */
public class ListUsers {

    /** Creates a new instance of ListUsers */
    public ListUsers() {
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Digite seu usuário do GMail (sem o @gmail.com) e pressione enter:");
        String user = scan.nextLine();
        System.out.println("Digite sua senha: ");
        String pass = scan.nextLine();
        ConnectionConfiguration config = new ConnectionConfiguration("talk.google.com", 5222, "gmail.com");
        config.setSASLAuthenticationEnabled(true);
        config.setReconnectionAllowed(true);
        XMPPConnection connection = new XMPPConnection(config);
        try{
            connection.connect();
            System.out.println("Conectou Bem!!");
            System.out.println("n Usando o Login: " + user);
            connection.login(user, pass);
            Presence presence = new Presence(Presence.Type.available);
            connection.sendPacket(presence);
            System.out.println("n Logou Direitinho!!!");
            Roster roster = connection.getRoster();
            Collection<RosterEntry> entries = roster.getEntries();
            for (RosterEntry entry : entries) {
                System.out.println(' ' + entry.getName() + 't' + entry.getStatus() + 'n');
            }

            connection.disconnect();
            System.out.println("Disconectado Ok!");
        } catch(XMPPException xe) {
            xe.printStackTrace();
            System.out.println("n Mas Fez Caquinha!!!!");
        }
    }
}

Observação importante: Não use a versão de release, a 3.0.3. Há um bug no método login. Use no entanto a 3.0.4 beta1, que não tem esse problema.

Abraços,