E chegou a hora de tirar a poeira daqui, tem muita coisa acontecendo e, com minha memória de rato, acabaria esquecendo de de relatar algum fato interessante, ou de levantar alguma questão de valor.

Bem, o que dizer então? Android? Nah, isso merece um post por si só… (só um adendo, já tem gente gerando os builds de android no ant)

E até que enfim consegui achar uma figura que deixa bem claro por que Go é tão mais complicado que xadrez pra simular no computador.

E tô de volta a programação funcional, agora com python e lendo vorazmente o “purely functional data structures” do okasaki, pena que ainda não consegui descobrir o que tem de difernete do livro dele pra o pdf da dissertação de mestrado do mesmo.

P.S.: Dei uma relida nesse post e tá caótico. Vamo ver se nos próximos eu consigo ser mais conciso.

Mais de um mês sem postar, mas isso não quer dizer que nada aconteceu… muito pelo contrário, além de uma visita ao Google Belo Horizonte, alguns campeonatos do Topcoder e reviravoltas no trabalho, resolvi implementar o que tinha dito uns 2 posts passados (implementar Torre de Hanoi usando Processing). Pois é, no meio do caminho, decidi que seria mais interessante fazer somente a simulação e não imprimir o resultado do algoritmo, isso significa que tenho uma implementação de um ‘jogo’ de torre de Hanoi em Processing. O código não está nem perto de bonito, apesar de existirem classes, o conceito de information hiding não é muito aplicado, não há como partir um projeto em mais de um arquivo, portanto, entre outros entraves. Entre mortos e feridos, fiz o possível pra não deixar o código macarrônico, mas …

Um screenshot da minha primeira aplicação em Processing:
Torre de Hanoi em Processing

Caso alguém se interesse, o código segue abaixo:

class StackNode{
int value;
StackNode nextNode;

StackNode(int value){
this.value = value;
this.nextNode = null;
}
}

class Stack{
StackNode top;
int length;

Stack(){
this.top = null;
this.length = 0;
}

void push(StackNode node){
StackNode temp = this.top;
node.nextNode = temp;
this.top = node;
this.length++;
}

void pop(){
this.top = this.top.nextNode;
this.length–;
}

int getTopValue(){
if(this.length == 0){
return 1;
} else{
return this.top.value;
}
}

int getValue(int pos){
StackNode tmp = this.top;

for(int i = 0; i < pos; i++){
tmp = tmp.nextNode;
}

return tmp.value;
}
}

int size_horizontal = 800;
int size_vertical = 600;
int frame_rate = 30;

int tower_width = 200;
int tower_height = 400;

int disk_width = 200;
int disk_height = 80;

boolean isPegSelected;
int pegSelected;

class Peg{
Stack stack;

int x;
int y;

Peg(int x, int y){
this.x = x;
this.y = y;

stack = new Stack();
}

void push(int value){
this.stack.push(new StackNode(value));
}

}

Peg[] pegs;

void resetPegs(){
pegs = new Peg[3];
pegs[0] = new Peg(150, 300);
pegs[1] = new Peg(400, 300);
pegs[2] = new Peg(650, 300);

for(int i = 0; i < 1; i++){
pegs[i].push(3);
pegs[i].push(2);
pegs[i].push(1);
}
}

void printPeg(int pos){
rectMode(CENTER);
fill(255,0, 0);
rect(pegs[pos].x, pegs[pos].y, tower_width, tower_height);

int yDisk = pegs[pos].y + 200;

for(int i = pegs[pos].stack.length 1; i >= 0; i–){
yDisk -= 25 + 50;
if(pegSelected == pos && i == 0){
fill(255, 255, 255);
}else{
fill(0, 255, 0);
}
rect(pegs[pos].x, yDisk, disk_width + pegs[pos].stack.getValue(i) * 12, disk_height);
fill(200, 0, 100);
text(“” + pegs[pos].stack.getValue(i), pegs[pos].x, yDisk);
yDisk -= 25;
}
}

boolean isInsidePeg(int pos, int x, int y){
return (x >= pegs[pos].x (tower_width/2)) &&
(x <= pegs[pos].x + (tower_width/2)) &&
(y >= pegs[pos].y (tower_height/2)) &&
(y <= pegs[pos].y + (tower_height/2));
}

void setup()
{
size(size_horizontal, size_vertical);
noStroke();
frameRate(frame_rate);
smooth(); //just to draw anti-aliased edges

resetPegs();

PFont fontA = loadFont(“CourierNew36.vlw”);
textFont(fontA, 36);
textAlign(CENTER);

isPegSelected = false;
pegSelected = 1;
}

void draw()
{
background(0, 0, 255);

//draw 3 pegs
for(int i = 0; i < 3; i++){
printPeg(i);
}
}

void mouseReleased(){
boolean insidePeg = false;

int i = 1;
for(i = 0; i < 3; i++){
insidePeg = isInsidePeg(i, mouseX, mouseY);
if(insidePeg == true){ break; }
}

if(isPegSelected == true){

if(insidePeg == true){
int topValueSelected = pegs[pegSelected].stack.getTopValue();
int topValueI = pegs[i].stack.getTopValue();

if(topValueI > topValueSelected){
pegs[i].push(pegs[pegSelected].stack.getTopValue());
pegs[pegSelected].stack.pop();
}
}

isPegSelected = false;
pegSelected = 1;
} else{
if(insidePeg == true){
isPegSelected = true;
pegSelected = i;
}
}
}

Eu seria um elfo.

Eu, um elfo
Peguei no blog do Marcelo

E apesar de não ter atualizado o blog nos últimos tempos, várias coisas aconteceram. Entre muitas movimentações no trabalho (haptics e física ainda dão um baita dum trabalho pra funcionarem juntos), comprei vários livros que estava querendo, entre eles “Antologia do Carnaval do Recife” do Mario Souto Maior, “Maracatus do Recife” do Guerra Peixe (é, o cara que ensinou Sivuca e fez arranjos pra Tom Jobim e Chico Buarque). Além disso, terminei de ler Snow Crash, ficção científica de primeira, aliás, foi até esse autor que cunhou o termo avatar, usado até hoje no contexto de Realidade Virtual, e outra contribuição sensacional foi o conceito de Metaverso, que apesar de já ter aparecido algo parecido em Neuromancer (provavelmente em outros autores de ficção também), tem muito mais detalhes e é absurdamente parecido com Second Life, tanto que semana passada até li uma entrevista com o inventor do SL e ele cita Snow Crash.

Bem, gostei tanto do estilo do Neal Stenphenson que comprei “The Diamond Age”. Esse merece um post logo mais, quando a leitura estiver mais adiantada. E só pra fechar essa ala literária, hoje compre “Do Frevo ao Manguebeat” do José Telles, fazia um tempo que estava atrás, finalmente encontrei num sebo de São Paulo, via o estante virtual. Grande jogada essa de congregar sebos virtuais.

E sobre engenharia de software, bem, estou basicamente lendo os effective c++ do Meyers, os 2 livros do Joel Spolsky e o Code Complete do McConnell. Grandes livros, mentes geniais. O Code Complete merece um post à parte, pois apesar de soar intuitivo, está repleto de conselhos e visão não-distorcidas sobre as várias fases pelas quais um projeto de software (de qualquer tamanho) passa.

Por último, pra quem gosta de música boa, visitem o blog que eu participo, o som barato.

E era isso.

Nesses últimos dias fiquei encucado sobre o que postar aqui no blog, muita coisa rolando mas eu sempre postergando o post, pois bem, hoje decidi que era a hora de arranjar um tempo e escrever algo.

Hoje viajando e lendo umas coisas por ai, acabei me deparando com esse ambiente de programação dinâmico (não, não tem nada a ver com programação dinâmica, que estou guardando um post há tempos…) chamado Processing . Segundo os autores, processing é bem mais que somente mais um ambiente de aprendizado de linguagens de programação, ele se propõe a ser uma IDE para desenvolvimento de obras de arte, sejam elas músicas, pinturas ou animações. Tem um bocado de screenshot lá, algumas com coisas bastante sofisticadas, como a estrela de Kock e uma simulação de fumaça . A linguagem utilizada é java-based e parece ser bem simples de usar. E só pra ir na onda do Paul Graham, copy what you like, amanhã ou depois, vou estar postando um código demonstrando as torres de hanoi em processing, imitando o Amit Singh. A razão de não fazer isso hoje é por conta do Google Code Jam Latin America, cujo Round 1 vai se dar amanhã e eu, felizmente, consegui uma vaga entre os 500, tomara que dê pra chegar entre os 50. Foi legal a participação até agora porque dei uma desenferrujada em assuntos que não via há algum tempo, e principalmente porque vou ver se dá pra participar de alguns campeonatos de algoritmos no topcoder.

that’s all, folks.

Depois de um longo e tenebroso inverno (clichè), estou de volta por conta da sugestão de um cara com quem conviv lá no trabalho por algum tempo e que está indo morar em Fortaleza agora: o maníaco do machado, Emanoel Xavier.

Bem, ontem nas minhas caoticidades (vide “Leituras Caóticas”), estava lendo sobre implementação de Singletons em C++ (e todas as suas dificuldades e gambiarras, mas elocubrações para outro post…) e acabei descobrindo um jeito diferente de dar um new: o placement new.

Segundo a biblioteca padrão de C++, um placement new é somente um overloading de new com passagem de parâmetros adicionais e cuja implementação-padrão não aloca memória. Deixa eu explicar com um exemplo de utilização, depois adentro o mundo das cobras:

Utilização:

class A{
public:
A(){}
~A(){}
...
};
A *p = new A;
...
delete p;
...
p = new (a,b) A; // onde a e b sao objetos ou tipos primitivos quaisquer

Na linha em negrito está o pulo do gato, a sintaxe é diferente do new usual, visto que agora dá pra passar parâmetros.

Bem, eu falei lá em cima que a implementação-padrão não aloca memória, ou seja, em algum dos parâmetros passados no placement new a memória já foi alocada, o que eu quero dizer com isso? A implementação de um placement new parece com algo do tipo:

void *operator new(size_t, void *ondeColocaOObjeto)
{ return ondeColocaOObjeto;}

Vale salientar que o fato de que quando acontece alguma exceção em um construtor o delete correspondente também é chamado, com os mesmos parâmetros e mesma ordem, isto é, quando acontece uma exceção em um placement new com parâmetros a, b e c, o respectivo placement delete com parâmetros a, b e c é chamado.

Bem, a MS agora resolveu ‘abrir’ o sdk de desenvolvimento do Xbox 360. Basta pagar uma módica quantia de $100 dólares por ano e conseguir compartilhar seu código com outros desenvolvedores. (É, parece que esse é o único senão da jogada…)

Como toda iniciativa MS, vale a pena ficar de olho, quem sabe as outras desenvolvedoras de console não abram o sdk também!? (Quem não iria querer desenvolver pra wii?)

Notícias sobre software e tecnologia em geral. Tentar explicar técnicas pra mim mesmo vai ser o grande fundamento desse blog.
Como diz Silvio Meira , mude ou morra. O que isso quer dizer pra mim? Estou mudando um pouco meus interesses, de engenharia de software em alto nível, para algo mais baixo nível. Meu plano, em 3 ou 4 meses, é comprar um primeiro conjunto de hardware (lego mindstorms ou algum microcontrolador), pra começar a brincar.

Além disso, muitas oportunidade$ surgindo. Mas como eu sempre falo: “É necessário desistir de sonhos para dar lugar a outros”. Vamo ver no que dá.

P.S.: O título é uma expressão de Luiz Gonzaga, no “Volta pra curtir”, disco gravado no teatro Tereza Raquel, no início da década de 70. Numa tentativa (bem sucessida) de trazer de volta o rei do baião.