O CSS (Cascading style sheets) fornece ao programador todo o controle do posicionamento de elementos em um documento HTML. Desde que o CSS tornou-se a uma tecnologia promissora, surgiu a pergunta: qual é melhor, o design usando CSS ou tabelas HTML ?

• Há alguns anos, o suporte à scripts CSS evoluia lentamente, enquanto as tabelas HTML eram plenamente suportadas por todos os navegadores existentes. Hoje em dia, essa diferença diminuiu significativamente;
• As tabelas HTML são mais flexíveis quando a janela do navegador é redimensionada, reescalando e quebrando seus elementos, enquanto o CSS é mais preciso quanto ao posicionamento, porém bastante inflexível;
• As tabelas HTML são mais simples de serem manuseadas do que as regras CSS;
• O CSS evolui a cada dia, surgindo novas funcionalidades com tal evolução;
• Como dito anteriormente, o CSS é mais preciso do que as tabelas HTML, permitindo que a sua página seja visualizada exatamente da forma que o web designer desejar;
• O uso de CSS pode deixar o código bem mais organizado do que diversas tabelas aninhadas, facilitando a edição e leitura do código.

Assim, pesando os prós e contras de cada uma das técnicas, deve-se escolher qual delas é mais útil e adequada ao modo de trabalho do programador.

Leia também:

1. Rapidinha: Compilando um programa C++ com CUDA
2. Rapidinha: CpuFreq-Selector
3. Implementando Programas que Usam Vários Processadores

Olá, pessoas!

Esse artigo é dedicado aos usuários de gnuplot que necessitam dar aquela incrementada em seus gráficos, para facilitar a interpretação e chamar a atenção de quem os vê. O único pré-requisito para tal edição é exportar os gráficos para o forma Encapsulated Post Script, vulgo EPS.

Passo 01: Exportar os gráficos para EPS

Para exportar os gráficos para o formato EPS, basta colocar no fim de seu script Gnuplot as seguintes linhas:

set terminal postscript eps enhanced 20 color dashed
set output “arquivo.eps”
replot

Os termos na linha de comando que estão em itálico são opções da exportação, os quais podem ser trocados de acorodo com o desejado pelo usuário.

Passo 02: Instalando um editor de gráficos vetoriais

O formato EPS é um formato vetorial de imagens. Na prática, isso significa que a base da imagem não são os pixels, mas sim os pontos de curvaturas e cores da imagem, o que permite que você mude o tamanho, dê zoom na imagem sem perder resolução nem “serrilhar” a mesma. Um editor bem simples de usar e bastante potente é o Inkscape Vector Graphics Editor. Para instalá-lo, basta dar o comando:

sudo apt-get install inkscape

ou então acessar a página do programa (http://www.inkscape.org/) e baixar o pacote.

Passo 03: Transformando o EPS para PDF

Apesar de ser um ótimo editor de imagens, o Inkscape não consegue abrir figuras EPS, apenas salvar nesse formato. Sendo assim, é preciso transformar o arquivo para o formato PDF, o qual o Inkscape consegue abrir normalmente. Para isso, basta fazer:

epstopdf arquivo.eps

e será gerado o arquivo.pdf

Passo 04: Editando o arquivo PDF

Agora é só abrir o arquivo com o Inkscape. Abaixo tem um exemplo de como fica um gráfico aberto com o mesmo. Neste gráfico, a legenda do mesmo foi colocada alinhada verticalmente, para aproveitar melhor o espaço da figura.

Exemplo de gráfico aberto com o Inkscape

Após abrir o arquivo, é necessário desagrupar as linhas do gráfico. Para isso, basta clicar com o botão direito em cima da imagem e clicar em “Ungroup” sempre que um bloco estiver agrupado, assim será possível a edição de cada elemento do gráfico.

O Inkscape tem muito mais opções de cores, linhas, espessuras, pontilhados, além de outros atributos. Com isso, você conseguirá deixar seus gráficos muito mais claros e atraentes aos olhos de quem o analisa.

Leia também:

1. Precisando fazer anotações em um PDF? Aqui vai uma boa dica
2. Criando PDF com BrOffice
3. Não tem Adobe Reader. E agora?

Para quem utiliza os dois sistemas operacionais na mesma máquina, é comum precisar de um arquivo que está em outra partição. No caso de estar no Linux e precisar de algo do Windows, o sistema possui ótimo suporte para partições FAT e até mesmo NTFS. Já o Windows, nada amigável com seus vizinhos, não tem qualquer interesse em “enxergar” um sistema de arquivos como o EXT2, EXT3 e ReiserFS. Mas tudo pode ser remediado.

Partição Ext2 no Windows

Ler partições EXT2 e EXT3 no Windows

Para executar tal tarefa, basta instalar o Ext2 IFS, que promete (e cumpre) a missão de tornar possível a leitura e escrita neste sistema de arquivos a partir do Windows (NT4.0/2000/XP/2003/Vista). Após a instalação, a partição assumirá uma letra que você designar, logo você poderá acessar seus arquivos abrindo o Windows Explorer e selecionando, por exemplo, a partição H: . O Ext2 IFS é um driver que adiciona ao ambiente Windows a capacidade de gerenciar este sistema de arquivos. Para baixar esse driver:

http://www.fs-driver.org/download/Ext2IFS_1_11a.exe

Ler partições ReiserFS a partir do Windows

Para quem faz uso do ReiserFS, há um software portátil para leitura e cópia dos dados. O software se chama YAReG, é super leve e simples, bom para quebrar aquele galho. Com ele você acessa os diretórios da partição, e tem a opção de copiar os dados para um outro local (por exemplo, uma partição NTFS, um pen drive, etc). Para baixá-lo:

http://yareg.akucom.de/index.html#DOWNLOAD

Bom pessoal, estes são os softwares que utilizo quando preciso acessar esses tipos de sistema de arquivos, há outros na internet, inclusive para XFS e outros, quem souber e quiser deixar aqui a dica para todos, fique à vontade!

Até a próxima!

Leia também:

1. Nota rápida: pesquisando o conteúdo de diversos arquivos (linux)
2. Instalando OpenOffice (BrOffice) no Windows
3. Como desabilitar autorun no Windows XP

Antes de qualquer outra palavra, gostaria de postar aqui um pedido de desculpas aos leitores, devido a diminuição considerável de novas postagens. Entretanto, os membros do time TS estão coincidentemente passando por períodos de mudanças e muito trabalho. Tentaremos, à medida do possível, voltar ao ritmo normal.  Bom, agora, com a cara de um cachorro que quebrou o vaso da dona, eu volto a falar-lhes sobre as novas “aventuras” da computação de alto desempenho, COMPUTAÇÃO HETEROGÊNEA!

A computação de alto desempenho contemporânea vem tomando rumos não imaginados há alguns anos atrás. Enquanto os computadores mais rápidos do mundo alternavam entre arquiteturas complexas e um número grande de processadores comuns, novas máquinas bastante potentes vem juntando diversas arquiteturas e componentes para ganhar desempenho com baixo custo.

O RoadRunner, o supercomputador mais rápido atualmente, é composto por processadores PowerXCell 8i 3.2 Ghz, os quais integram os velhos conhecidos PowerPC com alguns processadores auxiliares dentro de um mesmo núcleo, e por processadores Opteron DC 1.8 GHz. Os processadores AMD são responsáveis pelo controle dos dados, e os Cell fazem a parte pesada dos cálculos, resultando assim em cerca de 1,1 PFlops de desempenho.

Já o TSUBAME apresenta algo ainda mais inovador: mesclar processadores “comuns” AMD Opteron 2.4/2.6 GHz, Intel Xeon E5440 2.833 GHz com arquiteturas mais complexas, como o ClearSpeed CSX600, processadores dedicados a operações matemáticas, além do uso de placas de vídeo nVidia GT200, auxiliando nos cálculos massivos com o CUDA.

Com a tecnologia de integração, fica mais fácil a integração de sistemas já existente para obter mais performance. Assim, se esta vertente da HPC (High Performance Computing) firmar-se como tendência mundial, veremos um número muito grande de sistemas contendo diversas tecnologias antes usadas separadamente, o que parece ser bom, pois o custo de tecnologias Off-the-shelf são menores que os produtos de ponta. Assim, teremos máquinas potentes em computadores pessoais, e não somente em grandes pólos.

See ya!

Leia também:

1. O que é Física Computacional ?
2. Implementando Programas que Usam Vários Processadores
3. Usar Fortran ? Por quê ?

Em meus primeiros passos no aprendizado de programação em CUDA, tive um problema muito básico, mas que foi difícil encontrar a solução do mesmo: como compilar um programa escrito em C++ for CUDA ???

Vejamos um exemplo de código, o arquivo teste.cu

//**********************************************************************************************

cudaArray* cu_array;
texture<float, 2> tex;

// Allocate array
cudaMallocArray(&cu_array, cudaCreateChannelDesc<float>(), width, height);

// Copy image data to array
cudaMemcpy(cu_array, image, width*height, cudaMemcpyHostToDevice);

// Bind the array to the texture
cudaBindTexture(tex, cu_array);

// Run kernel
dim3 blockDim(16, 16, 1);
dim3 gridDim(width / blockDim.x, height / blockDim.y, 1);
kernel<<< gridDim, blockDim, 0 >>>(d_odata, width, height);
cudaUnbindTexture(tex);

__global__ void kernel(float* odata, int height, int width)
{
unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
float c = texfetch(tex, x, y);
odata[y*width+x] = c;
}
//**********************************************************************************************

Para compilar este programa, primeiramente é necessário ter o compilador nvcc instalado, por meio das bibliotecas fornecidas pela NVidia.

Temos então a seguinte sequência de comandos:

nvcc -cuda teste.cu

Este comando irá gerar um código C++ a partir do arquivo teste.cu, guardando-o no arquivo teste.cu.cpp. Após isso, faz-se:

nvcc teste.cu.cpp -o teste.exe

E assim, teremos o executável tão desejado!

Espero que ajude!

See ya!

Leia também:

1. Rapidinha: CpuFreq-Selector
2. Rapidinha: CSS ou Tabelas HTML
3. Computação Heterogênea

Buenas, caros leitores!

Hoje venho aqui para uma nota rápida, porém bastante interessante. Você, usuário de distribuições Linux Debian-based (Ubuntu, Debian), sabe como configurar o desempenho de seu processador pelo sistema operacional ?

Por padrão, os processadores vem configurados no modo de economia de energia. Porém, em alguns casos, como o meu, queremos extrair cada recurso daqueles milhões de transistores em forma de pastilha. Uma opção é realizar a configuração na BIOS, porém há uma opção bastante interessante: o aplicativo cpufreq-selector.

Há as seguintes opções:

• -c ‘número do processador’ – para informar o número da CPU a ser configurada, no caso de otimizar apenas um dos núcleos de um processador multicore;
• -g ‘opção’ – para configurar o modo de operação de seu processador, com as opções powersave (economia de energia) e performance (para alto desempenho);
• -f ‘frequência’ – para setar a frequência de operação do seu processador, em KHz

Sendo assim, para configurar seu processador, usa-se o comando:

cpufreq-selector -n ‘#proc’ -g ‘modo’ -f ‘freq’

Assim, é possível ajustar o desempenho de seu processador via sistema operacional, de acordo com suas necessidades!

See ya!

Leia também:

1. Rapidinha: Compilando um programa C++ com CUDA
2. Rapidinha: CSS ou Tabelas HTML
3. Computação Heterogênea

O Fortran (FORmula TRANslator)  surgiu na década de 50, e veio evoluindo desde então. Nos primórdios de sua existência a programação era feita em cartões perfurados, e os programas eram executados em máquinas monoprogramadas executavam apenas um job por vez). Com o tempo, a linguagem evoluiu juntamente com os computadores que foram surgindo.

Entretanto, nesse meio tempo, outras linguagens surgiram. Após o grande sucesso da linguagem C e derivadas, fica no ar a pergunta: é preciso usar o Fortran ?

Um dos fatores responsáveis por essa indagação é ausência de ponteiros em Fortran, assim como a diferente forma de alocação de dados na memória. Em C, uma matriz é alocada da seguinte forma: os elementos de uma mesma linha são alocados sequencialmente na memória. Já no Fortran, os elementos de uma mesma coluna são alocados consecutivamente. Entretanto, poucas pessoas sabem dos bons atributos do veterano Fortran. É uma das poucas linguagens que possuem paralelismo em sua definição. Em apenas uma linha é possível realizar o produto elemento a elemento de duas matrizes, assim como soma e outras operações, sem uso de bibliotecas auxiliares. Além disso, devido ao seu grande uso pela comunidade científica, o Fortran é bastante otimizado para a computação de alto-desempenho, como o HPF (High Performance Fortran), uma extensão do Fortran otimizada para arquiteturas potentes e bibliotecas de otimização. Além disso, o Fortran é compatível com protocolos de comunicação para multiprocessamento (MPI, OpenMP e outros), permitindo obter desempenhos fantásticos em programas com grande volume de dados processados. Em programas que envolvem basicamente operações com matrizes, o Fortran é fenomenal!

Evidentemente, outras linguagens possuem grande desempenho, otimizações e bibliotecas auxiliares para resolver todo tipo de problema. Mas não podemos deixar o quase “sessentão” Fortran de lado devido a sua idade. Por mais que seja um “idoso”, está melhor que muita linguagem de 20 anos por aí.

Leia também:

1. Ambientes de programação interpretados
2. Usando Open MPI Em Programação Paralela
3. Implementando Programas que Usam Vários Processadores

Olá caro leitor, depois de algum tempo de descanso volto novamente a tratar de um assunto que tem tido bastante interesse da comunidade que trabalha com computação de alto desempenho. Pois uma forma de conseguir o tão desejado alto desempenho em um programa é fazendo com que este utilize vários processadores durante sua execução, mas como foi dito no último artigo que escrevi ( Implementando Programas que Usam Vários Processadores ), essa não é uma tarefa tão simples! O escopo desse artigo traz algumas dicas de ferramentas necessárias para criar um programa que ao ser executado use vários processos e que esses processos comuniquem entre si.

Como foi discutido no artigo citado acima, uma forma de implementar a programação paralela é usando as bibliotecas de passagem de mensagens (MPI). Portanto, se o leitor quiser testar os programas exemplos que darei durante os próximos artigos será necessário instalar o MPI, como sou adepto da filosofia Open Source, aconselho que instale o Open MPI,( mas se estiver usando o Windows, instale o MPICH, Por sua conta e risco). Como de praxe, a instalação do Open MPI é simples, basta baixar o código fonte (código fonte), descompactar o arquivo, entrar na pasta criada pela descompactação usando o console ou um aplicativo similar e em seguida dar os comandos usais para compilação e instalação de pacotes (./configure em seguida make, e como superusuário dar o último comando, make install). O Open MPI necessita de que alguns pacotes estejam instalados; por exemplo, se você quiser escrever seus programas em Fortran, será necessário que tenha o fortran previamente instalado em sua máquina, essa mesma regra é válida para as outras linguagens que você queira escrever seus códigos, tais como C e C++. Outro pacote que o MPI usa e, portanto, deve estar instalado é o ssh, pois é a partir do ssh que é feita a comunicação entre os vários processos do programa em execução.

Vamos criar um programa simples para verificar se sua instalação foi bem sucedida, porém primeiramente vou falar de uma premissa básica sobre o MPI que é a Inicialização e a Finalização. Para se fazer referências ou chamadas à qualquer rotinas MPI, é necessário que o MPI seja inicializado e antes do término do programa principal o MPI deve ser finalizado. Para isso são definidas rotinas nas linguagens de programação, aqui vou usar o C como exemplo, porém o procedimento é o mesmo para outras linguagens (o que muda é sintaxe da chamada da rotina).

int MPI_Init( int *argc,  char ***argv); // inicialização do  MPI

//Blocos de códigos  MPI

int MPI_Finalize( ); // finalização do MPI

Esses parâmetros definidos na inicialização do MPI (argc e argv), são aqueles parâmetros recebidos tradicionalmente pela interface da linguagem C, portanto tais parâmetros devem ser passados para inicializar o MPI antes de sua utilização. O valor de retorno dessa chamada é um código de erro, sendo assim, ele indica possíveis erros durante a inicialização do MPI. Se não houve nenhum erro durante a inicialização, o valor de retorno será MPI_SUCCESS; caso haja algum tipo de erro os valores serão diferentes, porém não são especificados pelo MPI.  E assim como a inicialização, a finalização é feita pela rotina MPI_Finalize( ).

Para compreender o processo de  inicialização e finalização das rotinas MPI bem como testar se a sua instalação foi bem sucedida, copie o trecho do código seguinte em um arquivo sem formatação e salve-o com o nome NumProcesso.c em seguida compili-o. Obs. Ao copiar e colar tome cuidado com as aspas!

#include <stdio.h>
#include <mpi.h>

int main(int argc, char **argv){
int quantos, rank;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &quantos);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
printf(“Processo %d de %d rodando \n”, rank, quantos);

MPI_Finalize();

return 0;

}

Para compilar um arquivo usando MPI basta seguir o seguinte procedimento: usando o console, entre na pasta que se encontra o arquivo e em seguida dê o comando mpicc NumProcesso.c -o processos.exe (obs. a extensão *.exe é opcional, na verdade nem é necessário usar nenhum tipo de extensão). Se a compilação ocorreu tudo certo, execute o programa recém compilado assim: mpirun -np 4 processos.exe, aqui “-np 4″ é o numero de processos que será aberto durante a execução do programa, neste caso são quatro processos. Para evitar que a cada processo aberto ele peça a senha, configure o servidor ssh para autenticação sem senha.

P.S. O Próximo artigo será: Os conceitos em que as rotinas MPI são construídas. Nesse artigo será abordado processos,  mensagens,  comunicadores e tipos de dados.

ERRATA:

Olá leitores do TecnoSapiens, em algum ponto do artigo foi afirmado que a comunicação entre os processos era feita pelo ssh, porém o ssh é utilizado para disparar os daemons responsáveis por executar os processos MPI. Normalmente a comunicação propriamente dita das primitivas MPI_ …  é feita sem segurança.

Claudinei Caetano de Souza.

Leia também:

1. Implementando Programas que Usam Vários Processadores
2. Ambientes de programação interpretados
3. Rapidinha: Compilando um programa C++ com CUDA

Sabe quando você está passeando por aí e se depara com um carro modificado pelo dono, com detalhes aerodinâmicos, rodas de liga leve e aquelas famigeradas e, por que não dizer, bregas luzes azuis debaixo da carroceria? Aquilo se chama Car Tuning, e os carros são “tunados”.

Mas a idéia do artigo não é personalizar o OpenOffice (no Brasil chamado de BrOffice) para deixá-lo mais bonitinho. Na verdade venho apresentar o que uma equipe de desenvolvedores criou tendo como base o OpenOffice: o Go-oo. Este novo software promete ser mais compatível com formatos de arquivos do Microsoft Office, mais livre, mais rápido e mais funcional. Com isto em mente, resolvi baixar e instalar o dito cujo, para ter uma noção.

Após fazer o download através desse endereço (baixei também o pacote de linguagem pt-BR), e instalação no Windows XP, me deparo com essa tela de boas-vindas típica da versão 3.0 do OpenOffice:

Comecei a testar alguns recursos. A suíte tem um tempo de carregamento inferior ao do OpenOffice, tem um ótimo suporte para importação de arquivos SVG, e também melhor compatibilidade com documentos em formato Microsoft Office, inclusive cálculos em planilhas do Excel e preenchimento de formulários . Ainda assim, percebi problemas de formatação na edição de arquivos Docx, tanto no OpenOffice quanto no Go-oo.

Meu conselho: pare de usar formatos proprietários, e se não for possível, pelo menos evite Docx. Infelizmente ainda vai levar algum tempo até se alcançar uma ótima compatibilidade com formatos da Microsoft, mas importante valorizar os avanços que a comunidade alcançou até hoje. Ah, e se tiver um carro, não coloque neon nele; isso não fará de você uma pessoa mais descolada.

Links:

Sobre o OpenDocument Format
Saiba mais sobre o Openoffice.org

Leia também:

1. Instalando OpenOffice (BrOffice) no Windows
2. Dica: Como abrir arquivos de formato Office 2007
3. Instalando novos modelos para o Microsoft PowerPoint 2003

Olá, amigo leitor! Eu sou Paulo, novo colaborador do Tecnosapiens e irei compartilhar com vocês as minhas (des)venturas tecnológicas, principalmente no uso do Linux.

Carneirinho FDP!

Eu esperava começar falando sobre o uso do Nokia 5310 em conjunto com o Ubuntu. Ou sobre o Gerenciador de Bibliografia Referencer. Mas havia um carneiro montês intrépido no meu caminho. Poucos dias antes de receber o convite do Rodrigo para participar do Tecnosapiens, eu havia (re)feito o upgrade do Ubuntu 8.04 (Hardy Heron) para o 8.10 (Intrepid Ibex). Parecia tudo funcionar a contento. Como eu disse, parecia…

Eu já havia feito este upgrade do Hardy para o Intrepid, mas não me lembrava o porquê de ter voltado ao Hardy. Primeiro foi o Referencer. Esse excelente Gerenciador de Bibliografia para o Gnome, mais leve e intuitivo que o JabRef, com a maravilhosa capacidade de preencher os campos de uma determinada referência bastando possuir o endereço DOI do artigo, aumentou significavativamente meu tempo à toa minha produtividade. No entanto ele simplesmente não funcionava no Intrepid. Ele resmungava que uma biblioteca, que não me lembro qual era, tinha um problema. Como não sou de desistir na primeira tentativa, apaguei as configurações do Referencer, reinstalei a versão do mesmo para o Intrepid, procurei updates… nada resolveu o problema. Tudo bem, nem queria falar sobre o Referencer mesmo.

Bom, então vou falar sobre a experiência não-tão-completa (não encontrei meios de sincronizar agenda e contatos, mas a transferência de arquivos funciona muito bem sem a necessidade de kung-fu de terminal, tanto via USB como Bluetooth) de usar o meu novo celular no Ubuntu, o tal Nokia 5310.

Meu novo brinquedo

Conectava-o ao meu computador via USB e logo ele começava um processo de leitura do cartão de memória que nunca encerrava. Já havia transferido arquivos do Hardy para ele sem nenhum tipo de problema. Temia que o sistema de arquivos do cartão tivesse corrompido. Procurando mais um pouco encontrei isso. Aí já era demais, ter que recompilar kernel para resolver isso?! De volta ao Hardy.

O que me assusta é que já tive que abandonar o meu querido KDE por conta de um estranho bug na versão 4.1, que faz a tela piscar de modo bastante irritante. Não encontrei ninguém mais reclamando de tal problema, talvez seja só comigo. Agora esses problemas com o Intrepid. Pelo andar da carruagem meu próximo upgrade será para o Windows 7. Ou melhor ainda, para o OS X!

Leia também:

1. Agilidade com teclado: Gnome-Do
2. Editando gráficos gnuplot
3. Rapidinha: Compilando um programa C++ com CUDA