STK – Small Toolkit

Desde algum tempo, vinha amadurecendo a idéia de escrever uma toolkit de widgets básica baseada em Xlib… janelas, botões, textbox, progressbar, coisas simples assim que às vezes ajudam a criar programas simples para fins específicos. Bom, isso já existe, não há novidade nenhuma, pois para ambientes XWindow, existem inúmeras toolkits para desenhar interfaces gráficas, como GTK+, Qt, wxWidgets, etc. Basicamente já utilizei algumas delas em projetos que trabalhei ou coisas pessoais, mas meu desejo mesmo era escrever a minha. Depois de quase 1 ano pensando esparsamente nesta idéia, um dia, depois de uma viagem de 6 horas entre SP e RJ, cheguei em casa, encontrei meu primo, tomamos umas cervejas belgas e eu disse à mim mesmo: É hoje que eu começo a escrever esse negócio.

Logo após meu primo ir para sua casa, sentei e começei a ver como funcionava a Xlib. Ehhhh coisa estranha. Biblioteca doida demais, mas interessante ao mesmo tempo. Como a Xlib não te oferece widgets, mas somente primitivas geométricas e janelas básicas, tive que começar a ler códigos e códigos alheios para entender seu funcionamento. Depois de ver como eu poderia ter pelo menos um janela básica, era hora de começar a pensar como eu ia escrever o event listener dos widgets, o cara basicamente que trata os eventos que acontecem com os widgets, como click, drag, keyboard, etc. Passei metade da noite escrevendo o event listener, depois uma janela que se registrasse nele e respondesse à eventos. De primeira funcionou! Fiquei muito feliz, pois era o embrião de uma toolkit já!

No dia seguinte resolvi escrever botões, pois são essenciais para que ações sejam tomadas dentro de um programa com UI. Passei  meu dia escrevendo o botão, e no final, tinha um quadradinho que respondia à clicks e chamava callbacks, foi o máximo! No outro dia eu escrevi os efeitos do botão, para que desse a impressão de estar afundando quando pressionado. Depois de mais alguns ajustes no dia seguinte, resolvi que era hora de fazer um textbox, tanto para entrada, quanto para saída de texto. Como sou um belo preguiçoso (afinal sou programador), resolvi ir catar os fontes de alguém para ver se dava pra copiar algo, mas para minha frustração e sorte (explico depois), não achei nenhum código que eu pudesse adaptar facilmente ao meu.

Iria dar mais trabalho copiar e ajustar os códigos que eu achei do que escrever o meu próprio, o que mesmo assim, não me fez escrever o textbox logo em seguida. Conversando com um amigo, Rodolfo Lima, um ótimo programador que também já tinha feito uma toolkit gráfica, perguntei, “Cara, como você fez a entrada de texto da tua toolkit?”, e pra minha surpresa, ele disse, “eu não fiz, ia dar trabalho demais, é complicado e eu não tinha tempo pra escrever”. Ele me encorajou a escrever a minha! Por sorte (a sorte citada anteriormente que não parecia sorte nenhuma) de ter lido tanto código de pessoas que tinham feito isso, consegui pegar o conceito e comecei a escrever a minha, sem medo de fazer besteiras ou simplesmente não conseguir.

Depois de dois dias, voilà, tinha uma textbox que eu conseguia digitar texto, com rolagem vertical e tudo. Claro, era (ainda é) bem básica, tinha alguns problemas, agora resolvidos! Ela quebra um galho pra maioria dos casos. Após essa pequena jornada, comecei e pensar em outros widgets, para realmente ter algo que alguém pudesse usar para criar aplicações básicas. Ontem eu terminei minha progress bar, o resto eu deixo para vocês verem, tanto como código quanto como vídeos que eu tenho gravado em cada etapa do desenvolvimento.

Fontes do projeto:

https://github.com/gabrield/stk

Vídeos:

http://www.youtube.com/playlist?list=PLGB6MLZuwlwryn4u2ttf3EbYDe2D6TDnZ&feature=view_all

Feedbacks, dicas, críticas, entre outros, são bem-vindos!

Abraços!!!

Brincando com eLua + MBed

 +  

Há algumas semanas atrás, ganhei de presente uma placa de desenvolvimendo MBed LPC1768, doada pelo Mauro Baraldi. Uma doação muito bem recebida, que vai gerar outro post aqui logo logo! :)

Bom, fiquei olhando pra ela uns dias até que o Dado Sutter, meu jedi preferido e amigo, resolveu me ajudar a colocar eLua neste briquedo e fazer uns leds piscarem. O processo é tão simples que eu não acreditei muito quando vi a coisa funcionado. Vou tentar explicar da forma mais fácil, usando o eLua Builder. Crie sua conta lá e à partir dai, podemos começar! O processo é simples… Assim que estiver conectado, verá uma tela e o botão “New Project”. Clique nele e isto o levará à página onde as definições do build serão definidas.

Nesta nova página, há um campo “Project Name” onde você pode definir o nome do projeto, pois ele ficará guardado na sua conta caso queira reutiliza-lo. Logo abaixo há “Target Platform”, uma lista com as placas alvo que eLua pode ser compilada. Escolha “MBED”. Há outras opções mais avançadas, como colocar os scripts dentro da imagem binária que será gerada, etc, mas isso fica pra outro post. :p

Após este processo, na parte de baixo da página, existe o botão “Save and Generate”. Clique-o e uma janela vai aparecer, oferecendo a imagem binária e o conteúdo todo da imagem, como um arquivo zip. Clique sobre “Download binary image”. Agora é hora de colocar a imagem na placa, escrever um pequeno script para piscar leds e acessar a placa via screen para ver os resultados.

Assim que a MBed é conectada à USB do seu computador, ela é montada como um dispositivo de armazenamento (pelo menos no Mac OS/X e Linux). Algumas distros Linux não montam automaticamente, mas ficam com o ícone ou algo similar para que o dispositivo seja montado. Após montado, copie a imagem binária que foi baixada para dentro da placa. Pronto, agora é só apertar o botão em cima da MBed para reinicializa-la e voilà, eLua já está instalada na sua placa! Ai você me pergunta – “Mas… a placa não faz nada ainda, porque?” – E eu respondo – “Pois ainda vamos escrever o script para rodar nela”. Copie o código abaixo para um aquivo “piscaled.lua”.

-- eLua blinking led example, the Hello World of embedded :)

local uartid, invert, ledpin = 0, false
if pd.board() == "SAM7-EX256" then
  ledpin = pio.PB_20
elseif pd.board() == "EK-LM3S8962" or pd.board() == "EK-LM3S6965" then
  ledpin = pio.PF_0
elseif pd.board() == "EAGLE-100" then
  ledpin = pio.PE_1
elseif pd.board() == "STR9-COMSTICK" then
  ledpin = pio.P9_0
elseif pd.board() == "LPC-H2888" then
  ledpin = pio.P2_1
elseif pd.board() == "MOD711" then
  ledpin = pio.P1_7
  uartid = 1
elseif pd.board() == "ATEVK1100" then
  ledpin = pio.PB_27
  invert = true
elseif pd.board() == "STR-E912" then
  ledpin = pio.P6_4
elseif pd.board() == "ELUA-PUC" then
  ledpin = pio.P1_20
elseif pd.board() == "ET-STM32" then
  ledpin = pio.PA_5
elseif pd.board() == "STM32F4DSCY" then
  ledpin = pio.PD_13
elseif pd.board() == "MBED" then
  ledpin = mbed.pio.LED1
  mbed.pio.configpin( ledpin, 0, 0, 0 )
elseif pd.board() == "MIZAR32" then
  ledpin = pio.PB_29
  invert = true
else
  print( "\nError: Unknown board " .. pd.board() .. " !" )
  return
end

function cycle()
  if not invert then
    pio.pin.sethigh( ledpin )
  else
    pio.pin.setlow( ledpin )
  end
  tmr.delay( 0, 500000 )
  if not invert then
    pio.pin.setlow( ledpin )
  else
    pio.pin.sethigh( ledpin )
  end
  tmr.delay( 0, 500000 )
end

pio.pin.setdir( pio.OUTPUT, ledpin )
print( "Hello from eLua on " .. pd.board() )
print "Watch your LED blinking..."
print "Enjoy eLua !"
print "Press any key to end this demo.\n"

while uart.getchar( uartid, 0 ) == "" do
  cycle()
end

Este código serve para todas as placas que o builder suporta. Poderia dar uma limpada nele para só servir para MBed, mas decidi deixar assim, mais genérico. Copie este arquivo para dentro da placa da mesma forma que fez com a imagem binária de eLua. Novamente, reinicie sua placa. Agora acessaremos a placa usando screen. Caso não tenha o screen instalado no Mac, pode instalar via HomeBrew. No Linux, isto dependerá do seu gerenciador de pacotes. Deixo a instalação do screen por sua conta :p. No momento, estou no Mac OS/X e para acessar minha placa, usei o seguinte comando:

sudo screen /dev/tty.usbmodem622 115200 8n1

OBS: O dispositivo /dev/tty.usbmodem662 pode mudar, então cheque caso não seja o mesmo. No Linux, com certeza o dispositivo será diferente, algo como  /dev/ttyUSB0, então olhe antes de acessar via screen.

Pressione enter e normalmente você estará dentro do shell eLua. Digite “lua /semi/piscalua.led”. Isto chamará o script que colocamos na placa e o led da MBed deverá comecar a piscar. Para sair do programa, a sequência de teclas Ctrl+z funciona. Comentários são bem-vindos :) Espero que você possa fazer muito mais com sua MBed à partir daqui. Até!

A neve acabou, mas as lembranças ficam…

… dos bons dias de snowboard com bons amigos…

Sem mais palavras para essa época muito boa que foi o inverno nos Alpes Franceses, com amigos brasileiros, fraceses e muitos mais! Com -22 °C, estavamos sorrindo, alucinados para o teleférico subir de novo e termos um pouquinho mais de emoção na descida seguinte. Alguns acidentes, cortes, tombos, mas a alegria é o que conta mais!!! Agradeço à todos que participaram desses maravilhosos momentos. Essas fotos que posto exemplificam um pouco de tudo de bom que passei nessa temporada :)

Ainda achei uns videos filmados pelo baiano Vinicius, que trabalha no mesmo laboratorio que eu e participou da maioria dessas jornadas na montanha também:

Chamrousse Snowpark

Carioca em Les 2 Alpes

Até :)

Escola de verão de linguagem funcional para aplicações paralelas e concorrentes

Dos dias 11 à 22 de junho, estou participando de uma escola de verão sobre  linguagem funcional para aplicações paralelas e concorrentes, no CEA/Caradache, sul da França. Um lugar para aprender um paradigma completamente diferente de programar, principalmente para quem é acostumado com linguagens imperativas.

Basicamente a linguagem usada para aprendizado aqui é Haskell. Mostro um exemplo abaixo de um dos exercicios dados no curso:
addAll :: [Int] -> [Int]
addAll [] = []
addAll = map (\x -> x - 1)

addAll [1,2,3,3]

Essa função decrementa 1 de todos o elementos de uma lista. Nesta função, entram conceitos interessantes, como mapping, lambda calculus, pattern matching, etc… Para quem nunca viu linguagem funcional na vida, é uma coisa bem estranha largar todos os paradigmas aprendidos e ter que pensar de uma forma totalmente diferente, ainda mais quando se tem que usar recursividade quase à todo momento, sendo ela um das partes mais importantes de qualquer linguagem funcional.

Bom, estou somente no quarto dia de curso e a coisa esquentou bastante. Estou meio atrasado nas listas de exercicios, e acho que até o final do curso não as termino, mas espero me dedicar mais ao longo do tempo e usar Haskell pra mais coisas futuramente. Vou aproveitar o material distribuido pelos instrutores para aprender mais depois. O link com o material usado aqui se encontra logo abaixo, assim como outras referencias de Haskell que foram passadas aqui:

Espero postar talvez algumas fotos do Chateau que estamos hospedados, pois ao redor a paisagem é bem bonita :) Futuramente também pretendo postar mais alguns codigos pra ajudar iniciantes em linguagem funcional e se acharem e seguir em frente.

PS: Desculpem pela falta de acento em certas palavras. Estou usando um teclado francês, então é um pouco dificil :p

UPDATE 20/06/12

Slideshow de fotos da escola de verão:

Este slideshow necessita de JavaScript.

Até + !!!

Work @ Globo.com

É pessoal, tudo que é bom chego a um fim. Depois de algum tempo sem escrever aqui, volto para contar uma experiência curta, mas ótima em minha vida, tanto profissional quanto pessoal. Pra começar, lembro de todo o processo de seleção da Globo.com, entrevistas, etc…

Nunca tinha passado por um processo tão longo, mas que no final, valeu a pena. Depois de ter passado alguns anos programando em pequenos grupos e somente coisas de baixo nível, deparei-me com um lugar totalmente descontraido, aberto à novidades, com pessoas das mais diferentes “tribos” e habilidades. Mesmo me sentindo deslocado no começo (na verdade, ainda me sinto um pouco, pois ainda estava me acostumando com o ambiente). Não deslocado porque as pessoas me excluiam, mas porque eu não estava acostumado com a tecnologia usada e o tipo de produto que estava sendo feito. Todo esse ambiente de Python, Django, testes, Ruby, deploy, etc, tudo muito novo pra um cara que estava acostumando a brincar com bitwises, ponteiros, linkedição, drivers e afins. Tudo parecia uma grande bolha gigante, com várias pessoas fazendo-a crescer continuamente, de forma rápida e dinâmica, e na verdade, isso que me fez meus olhos brilharem. Desenvoler pra web sempre me pareceu uma coisa meio mística, ainda mais quando se usava um framework. O mais perto que eu tinha chegado foram alguns micro-softwares que escrevi em PHP para uso próprio, nada complexo, porém funcional. Além de ter aprendido sobre novas tecnologias, ter conhecido pessoas muito legais e com boa vontade, o pouco tempo que passei na Globo.com, aprendi a ver o mundo do desenvolvimento de uma forma diferente. Hoje consigo ver uma integraçao maior entre as coisas, entender como o planejamento e conversa entre partes é muito importante para que o produto que está em foco tenha sucesso.

Agora estou partindo para outra experiência, não profissional, mas pessoal, fora do país, e com muita tristeza, deixo este lugar extremamente legal. Se alguém tiver a oportunidade de trabalhar aqui, não pense muito em aceitar, pois com quase total certeza, não vai se frustrar.

Bom, até o próximo post, abraços!