Open Source Coders

JWS - Just Wanna Say

2011-05-13T14:28:00.005-03:00

Acho que todo mundo trabalha ou já trabalhou com aquele colega que passa o dia inteiro ouvindo música pesada num fone de ouvido que o isola completamente do mundo exterior. Diversas técnicas já foram criadas para chamar a atenção desses colegas, como por exemplo tentar falar muito alto, gesticular freneticamente ou tentar atingi-los com objetos diversos. Entre nós há alguns colegas assim, e também há o colega criativo que gosta de inventar maneiras inusitadas de resolver problemas. E foi nesse contexto que surgiu o jws, um programinha que lê coisas usando o serviço do Google Translate.

Inicialmente utilizado para sacanear nosso colega do fone de ouvido, o jws foi evoluindo até se tornar indispensável, com mil-e-uma utilidades e aplicações. Se você tem acesso ao Google Translate, um interpretador Python e por algum motivo precisa que um programa leia coisas, então o jws é ideal para você.

É sabido que o jws funciona bem em nossos sistemas Linux, mas ele deverá rodar tranquilamente em Windows ou Mac. E se por acaso ele não achar um jeito de tocar o áudio em seu sistema, é possível adicionar novos métodos de saída com bastante facilidade.

O jws é simples e fácil de usar. Experimente, por exemplo, o seguinte:

$ jws Olá, mundo.

Mas também há opções mais avançadas, que permitem escolher o idioma da entrada

e o backend de saída. Para ler um texto em inglês, com o mplayer, por exemplo,

podemos usar o seguinte comando:

$ jws --language=en --backend=external --backend-options=mplayer "Hello world! I'm a fancy little lovely text-to-speech program."

O código está disponível num repositório no bitbucket, mas você pode baixar um pacote diretamente aqui.

jQuery Google charts

2011-01-21T10:26:00.002-02:00

Pra quem precisa criar gráficos (charts) no seu site, fica a dica...

http://maxb.net/scripts/jgcharts/include/demo/

Biblioteca em jQuery que usa o Google Charts para criação de gráficos.
Pode-se criar gráficos tanto em barra quanto em linha, pizza, pizza 3D.
E inclusive gerar gráficos apartir de table html.

Exemplo1:
Basic Bar

//1 ) api 
var api = new jGCharts.Api();         
 
//2) options 
var opt = { 
    data : [[153, 60, 52], [113, 70, 60], [120, 80, 40]]//mandatory  
};//set options  
 
//3) append Img (with jQuery) 
jQuery('<img>') 
.attr('src', api.make(opt))//options  
.appendTo("#bar1");

Exemplo2:

Anno	Data 1	Data 2	Data 3
2001	153	60	52
2002	113	70	60
2003	120	80	40

jQuery(".jgtable").jgtable();

 <div class="jgtable"> 
  <table> 
  <thead> 
    <tr> 
        <th>Anno</th> 
        <th class="serie">Data 1</th> 
        <th class="serie">Data 2</th> 
        <th class="serie">Data 3</th> 
    </tr> 
  </thead> 
  <tbody> 
    <tr> 
        <th class="serie">2001</th> 
        <td>153</td> 
        <td>60</td> 
        <td>52</td> 
    </tr> 
    <tr> 
        <th class="serie">2002</th> 
        <td>113</td> 
        <td>70</td> 
        <td>60</td> 
    </tr> 
    <tr> 
        <th class="serie">2003</th> 
        <td>120</td> 
        <td>80</td> 
        <td>40</td> 
    </tr> 
  </tbody> 
  </table> 
</div>

Implementação da tela VGA em assembly

2011-01-05T12:24:00.003-02:00

Aproveitando o post anterior do THOR27 sobre a implementação de cores em sistemas operacionais, vou postar um pouco sobre como o computador transforma os seus comandos em cores visíveis na tela do computador. A implementação será feita em linguagem assembly do processador MIPS, um dos modelos de processador mais usados para ensinar arquiteturas de processadores.

Introdução

Se você não sabe o que é assembly, nada que uma boa pesquisa no Google não resolva, mas acho que vale a pena perder alguns segundos com a definição. Os computadores são baseados num dos princípios mais simples que existem em elétrica ou eletrônica. Se temos um fio que conduz eletricidade, existem duas possibilidades para ele em qualquer tempo: ou passa corrente ou não passa corrente. Se passa corrente, representamos como 1; se não passa, representamos como 0. Somente com essas simples definições é possível construir computadores como os que temos hoje, mas falar sobre isso ia tomar muito tempo, então deixo como pesquisa para quem quiser se inteirar.

O coração de todo computador é o processador, que se baseia nos mesmos princípios: ou passa corrente (0) ou não passa (1). Claro que a maior parte dos programadores não fica plugando cabos e conectores para descobrir as funções que podem ser executadas pelo processador, então todo fabricante publica uma especificação de seu código assembly, que basicamente diz todas as funções que podem ser executadas pelo processador.

Há uma grande discussão na indústria se o conjunto de instruções deve ser reduzido (RISC) para facilitar o aprendizado ou deve ser mais completo (CISC) para fornecer mais possibilidades de implementação ao programador. De modo geral podemos dizer que os computadores maiores utilizam CISC (processadores Intel e AMD) e os menores utilizam RISC (ARM e MIPS). Como o objetivo é mostrar uma possibilidade de implementação que seja fácil de entender, o processador que vamos utilizar no exemplo é o MIPS.

A principal vantagem do MIPS em relação aos seus competidores é que o conjunto mínimo de instruções contém apenas oito instruções, ou seja, o processador só executa oito diferentes comandos. E muito fácil então a qualquer programador conhecer os comandos que ele executa, ainda que seja difícil implementar algumas funcionalidades com tão poucos comandos. Passa a ser importante então uma outra característica de todo programador: a criatividade.

Voltando ao objetivo do post, o que queremos é possibilitar a escrita de alguma coisa na tela de um computador. Via de regra toda tela de computador é representada como uma sequência de pixels, ou o menor ponto que a resolução é capaz de representar. O computador desenha a tela quebrando a imagem em pontos no mesmo princípio que discutimos anteriormente: tem cor (1) ou não tem cor (0). Para facilitar o exemplo vamos trabalhar com a resolução de uma tela VGA que tem 640x480, ou seja, 640 pontos na vertical e 480 na horizontal. Então, sempre que quisermos desenhar o caracter, precisamos passar sua posição na horizontal, na vertical e indicar se o ponto contém luz (1) ou não contém (0).

Você deve estar se imaginando como é possível desenhar, então já vou entregar o maior segredo: nesse link está uma tabela que diz qual o código de cada um dos caracteres na famosa tabela ascii e como ele é representado. Guarde com cuidado, pois foi muito difícil encontrar essa informação. Podemos ver que cada caracter ocupa um espaço de 8x8 pixels, ou seja, 64 bits. São necessários então 64 bits para representar um caracter da tabela ascii numa tela VGA.

Código Assembly

Agora que já sabemos do que estamos tratando podemos passar para o código propriamente dito. O objetivo então é escrever um programa que tenha a capacidade de, dado um determinado caracter, escrevê-lo na tela na posição (x,y). Traduzindo para a linguagem assembly, vamos receber em um registrador e em outros dois a posição que ele deve ser escrito.

O primeiro passo é carregar na memória o mapa de caracteres VGA fornecido acima como dado para o programa.


 .data

char: .word 0x00000041 # Aqui vai o caracter ascii a ser impresso. 41 é A.

min: .word 0x00000021 # Abaixo disso, nenhum caracter será impresso (tudo 0)

max: .word 0x0000007F # Acima disso, a tela fica preta (todos os caracteres 1)

# Caracteres para a tabela ascii

ini: .word 0x00000021 # O primeiro caracter da tabela ascii

incr: .word 0x00000001 # Vou utilizar essa word para incremendar o contador

# Não consegui descobrir outra forma que não seja declarar os dados aqui

excla1: .word 0x08080808

excla2: .word 0x00000800

(...)

til2: .word 0x4C000000

pr1: .word 0x11111111 # Tudo 1

br1: .word 0x00000000 # Tudo 0

Já temos a primeira parte do programa, que é a declaração dos dados e variáveis. Agora passamos ao texto ou ao programa propriamente dito:

print_char:

lw $a0, char # A word representando o ascii que vai ser impresso vai em $a0

# Aqui começa a descrição dos caracteres que serão impressos. Uma verdadeira tabela de símbolos

lw $t1, max # Armazenamos a maior word representável no VGA

slt $t0, $a0, $t1 # Se a word for menor do que o maior valor representável, $t0 vai pra 1

beq $t0, $zero, pr # Se $t0 estiver em 0, significa que a word é maior que o máximo. Imprimos tudo preto.

lw $t1, min # Agora $t1 recebe o mínimo

slt $t0, $t1, $a0 # Agora se $a0 for menor que o mínimo, imprimimos tudo branco

beq $t0, $zero, br

# Agora fazemos a substituição dos caracteres

lw $t0, ini # Código ascii

(...)

# lw $t0, 0x0000007D # Código ascii

add $t0, $t0, $t1 # Próximo da fila

beq $a0, $t0, chav2 # Branch para o label de impressão do caracter

# lw $t0, 0x0000007E # Código ascii

add $t0, $t0, $t1 # Próximo da fila

beq $a0, $t0, til # Branch para o label de impressão do caracter

beq $a0, $t0, excla # Branch para o label de impressão do caracter

lw $t1, incr # Armazeno o valor a ser incrementado no registrador $t1

# lw $t0, 0x00000022 # Código ascii

add $t0, $t0, $t1 # Próximo da fila

beq $a0, $t0, aspas # Branch para o label de impressão do caracter

A lógica da chamada é simples e certamente pode ser melhorada (contribuições são bem vindas). O registrador $a0 possui o caracter que vai ser impresso na tela. O registrador $t1 é incrementado e vai verificando se o valor que possui é o que deve ser impresso. Quando encontra o valor que deve ser impresso, vai para a posição da impressão do caracter, representada abaixo:

excla: # Agora é dividir os bits: os primeiros 32 em $a1 e o restantes em $a2

lw $a1, excla1

lw $a2, excla2

j print # Depois vamos para a impressão

aspas:

lw $a1, aspas1

lw $a2, aspas2

j print # Depois vamos para a impressão

(...)

til:

lw $a1, til1

lw $a2, til2

j print # Depois vamos para a impressão

pr:

lw $a1, pr1 # Tudo 1

lw $a2, pr1 # Tudo 1

j print

br:

lw $a1, br1 # Tudo 0

lw $a2, br1 # Tudo 0

j print

Precisamos agora escrever na tela propriamente dita. A função abaixo representa a impressão:

# Se chegamos até aqui, hora de imprimir de acordo com a tabela

print:

la $t0, 0x00001001 # A impressão do caracter começa a partir do endereço 4097. Ponho em $t0.

sw $a1, 0($t0) # $a1 contém os primeiros 32 bits dos caracteres

sw $a2, 4($t0) # $a2 contém os próximos 32 dos caracteres

# sw $a1, 0($ra) # $a1 contém os primeiros 32 bits dos caracteres

# sw $a2, 4($ra) # $a2 contém os próximos 32 dos caracteres

jr $ra # Retorna para quem chamou

Parabéns! Você acaba de imprimir o seu primeiro caracter numa tela VGA.

Como pode ser facilmente percebido, o código não é nenhum pouco eficiente, e precisa ser integrado a outros programas em MIPS para ter alguma utilidade prática. Afinal, o caracter a ser impresso está hard coded na letra A. O exemplo serve mais para ajudar quem quiser começar a mexer com o assunto, porque quando estava estudando isso foi muito difícil achar exemplos para aprender.

Se tiver alguma sugestão, fique à vontade para apresentá-la. E não se esqueça de postar se conseguir tornar o código mais limpo e eficiente.

Obs.: Você pode baixar o código completo aqui.

As cores em RGB

2011-01-05T09:54:00.008-02:00

As cores RGB, utilizada para exibição de imagens em monitores, consiste na mistura de 3 cores primárias: O vermelho (Red ou R), o verde (Green ou G) e o azul (Blue ou B).

Hoje em dia, o número de cores existentes pode ser representado em 24 bits, ou seja, 8 bits para cada cor primária (8 do vermelho, 8 do verde e 8 do azul).

Existe um sistema operacional por aí que diz que utiliza 32 bits de cores, mas isso é mentira: Na verdade os 8 bits adicionais usado por esse sistema operacional são atalhos para outras cores representadas pelos demais 24 bits, traduzido como um canal alpha (utilizado para fazer "semi transparência"). Apesar do canal alpha ser amplamente utilizado não é necessário que ele esteja representado na paleta de cores, como faz esse sistema operacional popular.

Com 8 bits é possível representar 2^8 (dois elevado a oitava) tons de uma cor, que é igual a 256 tons, sendo representado de 0 a 255.

Logo temos a seguinte variação de cores: 256 tons vermelhos que podem se misturar com 256 tons de verde que por sua vez podem se misturar com 256 tons de azul, gerando uma combinação de 256x256x256 = 16.777.216 cores diferentes (os famosos 16 milhões de cores)

Na computação é muito utilizada a representação hexadecimal que consiste em utilizar a numeração de 0 até F (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F) ao invés do popular decimal (0,1,2,3,4,5,6,7,8,9,0).

Em hexadecimal, 255 é representado como FF. Logo a variação dos tons das cores podem ser representados 0 até FF

Para inidicar as cores RGB é amplamente utilizado o seguinte formato: #(VERMELHO)(VERDE)(AZUL) aonde o vermelho, o verde e o azul é substituido pelo seu valor em hexadecimal, por exemplo:

Vermelho = utilizar o tom 103 (67 em hexadecimal)
Verde = utilizar o tom 255 (FF em hexadecimal)
Azul = utilizar o tom 29 (1D em hexadecimal)

Logo essa cor fica representada como #67FF1D

Abaixo segue 2 pequenos scripts em shell, capaz de gerar as cores rgb no formato em hexadecimal e o oposto:

Retorna o valor das cores em decimal do valor informado no formato #RRGGBB:

#!/bin/bash
achacor(){
echo "{ibase=16; $1}" | bc
}
NOME_COR=$1
COR1=${NOME_COR:1:2}
COR2=${NOME_COR:3:2}
COR3=${NOME_COR:5:2}

echo R: `achacor $COR1` G: `achacor $COR2` B: `achacor $COR3`

Retorna o valor das cores no formato #RRGGBB do valor informado em decimal:

#!/bin/bash
achacor(){
echo "{obase=16; $1}" | bc | awk '{printf "%02s\n", $0}'
}
COR1=$1
COR2=$2
COR3=$3

echo '#'`achacor $COR1``achacor $COR2``achacor $COR3`

Exportando HTML para odt, pdf... etc

2010-12-09T11:41:00.007-02:00

SmartPrintNG

Ferramenta para exportar plone content para:
- PDF
- RTF
- ODT
- WML
- DOCX

SmartPrintNG:
O smartprint integra o zopyx.convert com o plone, porém quem faz de fato a conversão é o zopyx.convert

Plone.org - http://plone.org/products/smartprintng
download
pypi - http://pypi.python.org/pypi/Products.SmartPrintNG
download

zopyx.convert
o convert é uma ferramenta que converte HTML para um dos formátos listados.
Ele funciona em qualquer sistema (não somente plone), basta ter instalado o python 2.4+ e o java 1.5+

pypi - http://pypi.python.org/pypi/zopyx.convert
download

Por estar no pypi, eles podem ser instalado com o python usando o easy_install

Colocando code-completion no Python

2010-11-24T21:28:00.006-02:00

O terminal do python é muito útil para fazer testes, mas além de útil ele pode se tornar ainda mais prático!

A dica é simples: Copie o código abaixo, e cole no arquivo ~/.pystartup:

import atexit, os, readline, rlcompleter

histFile = os.path.expanduser("~/.pyhistory")

def saveit(hf=histFile):
readline.write_history_file(hf)

if os.path.exists(histFile):
readline.read_history_file(histFile)

readline.parse_and_bind('tab: complete')
readline.set_history_length(2000)

atexit.register(saveit)
del os, atexit, rlcompleter, saveit, histFile

agora execute o seguinte comando:

export PYTHONSTARTUP=~/.pystartup

Coloque esse comando no final do seu arquivo ~/.bashrc para que fique salvo para próximas seções shell.

Para usar, basta executar o terminal python e utilizar a tecla "tab" para completar os comandos digitados.

WWW SQL Designer

2010-11-19T16:50:00.004-02:00

Aplicação Web em PHP para modelagem de banco de dados.

Compatível com:
MySQL
PostgreSQL
SQLite
e outros

Site oficial:
http://code.google.com/p/wwwsqldesigner/

Download:
http://wwwsqldesigner.googlecode.com/files/wwwsqldesigner-2.5.zip

Limita Texto

2010-11-17T15:15:00.005-02:00

Esse código, em python, é bem interessante pois ele corta textos em um determinado tamanho sem que corte as palavras no meio se isso não deixar o texto menor que metade do texto.

Exemplo:

>>> from limita_texto import limita_texto
>>> limita_texto('Aqui vem o texto muito maior que o limite',20)
'Aqui vem o texto...'
>>> limita_texto('Aqui vem o texto muito maior que o limite',21)
'Aqui vem o texto...'
>>> limita_texto('Aqui vem o texto muito maior que o limite',22)
'Aqui vem o texto...'
>>> limita_texto('Aqui vem o texto muito maior que o limite',23)
'Aqui vem o texto...'
>>> limita_texto('Aqui vem o texto muito maior que o limite',24)
'Aqui vem o texto...'
>>> limita_texto('Aqui vem o texto muito maior que o limite',25)
'Aqui vem o texto muito...'

Você pode baixar o código aqui: Limita Texto

Ou pelo HG to Python Utils:

hg clone https://opensourcecoders@bitbucket.org/opensourcecoders/python-utils

loading js

2010-11-16T14:31:00.004-02:00

Ae galera primeiro post!

JavaScript/JQuery - Spinner para ação de loading

Já precisei disso várias vezes e acho que é sempre útil esse tipo de coisa, criei um 'plugin' pra jquery 1.4+ (é provável que funcione com versões anteriores).

Como funciona: (Basicamente ele só exibe e esconde um png)
1 - Vc precisará modificar o caminho pra imagem dentro do loading.js
2 - $.loading.show()
$.loading.hide()

obs: como é a primeira versão não foi incluído nenhum 'ie fix'

Download Zip:
https://bitbucket.org/opensourcecoders/loading_js/get/2e0147f81691.zip

HG:
https - hg clone https://opensourcecoders@bitbucket.org/opensourcecoders/loading_js
ou
ssh - hg clone ssh://hg@bitbucket.org/opensourcecoders/loading_js