| |||||||||||||||||||||||||||||||||||||||||||||||||||
Cada linguagem de programação tem a sua “etiqueta”. A linguagem Java não foge à regra. Há maneiras convencionadas para escrever os identificadores, os nomes dos métodos, os nomes das classes e interfaces, a indentação, etc..
Por isso recomendo a leitura (rápida) de um pequeno livro, ou a simples presença ao pé do teclado de um pequeno livro. Chama-se “The Elements of Java Style”.
Para quem não gosta de livros em papel, este livro está disponível online
A procura pela eficiência é um aspecto fundamental da programação. (Mas não mais importante do que a procura pela correção.)
Uma classe de algoritmos muito bem estudados em termos de eficiência são os algoritmos de ordenação. Queria aqui deixar um link para um sítio onde estes algoritmos são muito bem ilustrados numa animação feita em Java (numa Applet).
O exercício de escrever um programa só por si não tem nexo algum. O propósito de escrever um programa é o de resolver um problema. No entanto é uma tendência de muitas pessoas, pensar num problema, e começar a escrever código de seguida. Para resolver problemas com sucesso é necessário pensar um pouco mais profundamente, mesmo para os problemas mais simples.
Uma citação do livro (“Programming Pearls”):
“A Problem Solver’s Perspective: Good programmers are a little bit lazy: they sit back and wait for an insight rather than rushing forward with their first idea. That must, of course, be balanced with the initiative to code at the proper time. The real skil, though, is knowing the proper time. That judgment comes only with the experience of solving problems and reflecting on their solutions.”
Portanto, a mensagem deste post serve apenas para transmitir a ideia de que é preciso construir uma solução antes de construir um programa.
Tomemos como exemplo o exercício do corrector ortográfico pedido como exercício das aulas.
Pretende-se construir uma aplicação para aceitar frases da entrada padrão (standard input) e imprimir na saída padrão (standard output) as palavras que não sejam encontradas num dicionário dado. Podemos esquematizar a solução pretendida da seguinte maneira:
Carregar todas as palavras do dicionário de um ficheiro para memória
Repetidamente
Aceitar frase do input
Separar a frase em palavras
Para todas as palavras dessa frase
Verificar se a palavra existe.
Se a palavra não existe imprime-a
Podemos considerar que temos aqui uma descrição da solução do problema em grandes blocos. Temos agora que descrever a solução em mais detalhe e por fim escrevê-la utilizando uma linguagem de programação. O paradigma de programação utilizado nestas aulas é o paradigma orientado por objectos, e a linguagem, o Java. Devemos portanto desenhar a nossa solução segundo essa perspectiva, dividindo os dados e o processamento em objectos.
Ora, olhando para este problema temos claramente dois intervenientes: um dicionário, um objecto que guarda todas as palavras aceites e que verifica se uma dada palavra consta ou não desse conjunto; e temos outro interveniente, um verificador de frases, que dada uma frase a decompõe em palavras e verifica a sua existência no dicionário. Existe para além disso um objecto que é a parte visível da aplicação que estamos a construir, que implementa a interacção com o utilizador.
Criamos então uma classe Dicionário, cujos dados são as palavras aceites. Essas palavras devem ser carregadas de um ficheiro dado e guardadas em memória. Para além do carregamento das palavras, a classe dicionário tem apenas mais uma operação associada. A verificação da validade de uma palavra.
Quanto aos dados do dicionário, a estrutura de dados mais óbvia para guardar um conjunto fixo de palavras é um vector de palavras. Sendo um conjunto de palavras de dimensão considerável, a maneira mais correcta de pesquisar uma palavra num vector é a busca dicotómica (muito mais eficiente que uma busca linear). Para se poder efectuar uma busca dicotómica é necessário que o vector esteja ordenado. Note-se que o ficheiro dado já está ordenado (no entanto, mistura palavras com maiúsculas com palavras com minúsculas). Para resolver este “pequeno” problema, pode-se ordenar novamente com a ordem “normal” das palavras, ou alternativamente pesquisar ignorando o “case” das palavras ou guardando-as já sob a forma só com minúsculas (ou só maiúsculas). Utilizei a palavra “normal” acima para referir a ordem implementada pela classe string, pelo método compareTo onde as letras maiúsculas vêm todas antes das letras minúsculas.
Outra classe, que pode ser chamada de Corrector, guarda uma referência para um dicionário (fornecido na criação do mesmo), e aceita frases para serem verificadas. Essa operação tem como resultado um conjunto de palavras erradas (um vector).
Assim, a descrição acima (para a solução do problema) poderia ser traduzida da seguinte maneira no código da classe principal:
classe CorrectorApp {
public static final String DICT_FILENAME = "dictionary.txt";
public static void main(String args[]) {
Dictionary dict = new Dictionary(DICT_FILENAME);
Speller speller = new Speller(dict);
Scanner s = new Scanner(System.in);
while( s.hasNextLine() ) {
String[] wrongWords = speller.verify(s.nextLine());
for( String s: wrongWords) System.out.println(s);
}
}
}
Estão aqui evidentes partes do problema que não estão ainda resolvidas. A leitura das palavras do ficheiro, a pesquisa, a partição da frase em palavras, a construção do vector de palavras erradas, etc. O que aqui está presente é tão só a estruturação da solução, a identificação de problemas mais pequenos que podem ser resolvidos usando o mesmo método de decomposição de problemas.
Espero ter acendido algumas luzes mesmo que pequenas.
Estava a ouvir rádio e ouvi uma referência a um livro que eu gostei muito. Chama-se “A Sombra do Vento”, do escritor Carlos Ruiz Záfon.
É um livro daqueles que prende a nossa atenção por noites e noites, dias e dias… É uma viagem fantástica recheada de sentimentos, paixões, mistério… Imprescindível.
Hoje foi a primeira aula de introdução à programação dada por mim ao turno TP3 da LEI. (Em substituição do Professor Luis Marcelino.)
Serve este post como resumo e motivação para os alunos.
Após uma pequena introdução sobre a matéria dada, foquei a aula nos elementos básicos da programação, que no essencial já são conhecidos dos alunos. Estes elementos podem ser a partir de agora ser combinados para resolver problemas e/ou para criar novos elementos de granularidade mais alta que nos permitem resolver problemas mais complexos. A apredizagem de uma linguagem de programação deve apenas ser um meio para atingir esse fim, e não um objectivo em si.
Os elementos básicos são,
A matéria propriamente dita desta aula (e das seguintes) debruça-se sobre mais um elemento que podemos adicionar a esta colecção. A recursividade, a programação pelo método inductivo.
Ficou como trabalho extra a resolução do problema das permutações, amanhã veremos as vossas soluções e tentaremos obter uma solução consensual e correcta para o problema.
Esta aula começa a matéria do capítulo 18 do livro recomendado que aqui mais uma vez deixo o link e a recomendação para que o obtenham rapidamente. Os slides da aula de hoje já estão online so sitio do costume (aqui).
Não se esqueçam de que na página da cadeira já está online o enunciado do segundo trabalho e que devem começar a pensar na resolução dele.
Agora que terminei este longo caminho é um pouco tarde para ser eu próprio a beneficiar desta informação na sua extensão máxima, mas aqui fica o link para um site muito bem feito. Foi-me indicado pelo meu orientador (Luís Caires) nos últimos dias antes da discussão.
Tem uma exposição sistemática de todos os aspectos de um processo de doutoramento.
Está a partir de hoje acessível a página da especialização em Construção e Análise de Software. É uma especialização proposta pelo DI-FCT/UNL no âmbito do 2º Ciclo em Engenharia Informática (Mestrado).
Tal como se diz nesta página: “A especialização Construção e Análise de Software destina-se a formar Engenheiros Informáticos habilitados a participar no desenvolvimento de software de alta qualidade e sofisticação técnica.
Destina-se a candidatos com especial vocação para lidar com aspectos técnicos e delicados dos sistemas de software: especificação, algoritmia, modelação, arquitectura, validação e verificação, desenho e processamento de linguagens. Integrando as várias unidades curriculares propostas, o aluno aprende a lidar com a complexidade nos sistemas de software, e a usar técnicas avançadas de desenvolvimento e validação de sistemas.”
Finalmente a página do ComponentJ está de cara lavada. Na página que se pode encontrar sob a categoria Software irão aparecendo novas versões do compilador e da linguagem à medida que forem sendo desenvolvidas.
Esta é a primeira mensagem da nova versão da minha página. Vou tentar manter aqui um blog das minhas actividades de investigação, nomeadamente do software que for desenvolvendo.
Os projectos dos quais é esperado que apareçam aqui notícias são o componentJ e o interpretador do cálculo de componentes. Para já essas páginas ainda não estão completas (ainda continuam no local antigo, com as versões antigas) mas a seu tempo migrarão para a nova estrutura de página.