Friday, April 22, 2011

Afinar seu violão




A dificuldade do iniciante é que as cordas normalmente são contadas invertidas. Aqui vamos introduzir um novo conceito de nomenclatura de cordas de violão.

Para não confundirmos mais a nomenclatura, iremos chamar a nomenclatura antiga de inversa, e a nova de direta. A diferença se dá apenas na contagem da numeração das cordas. Então, na nomenclatura inversa você conta as cordas como 6ª, 5ª, 4ª, 3ª, 2ª e 1ª, de cima para baixo. Na nova nomenclatura, a direta, as cordas são contadas de cima para baixo como 1ª, 2ª, 3ª, 4ª, 5ª e 6ª. Vamos para a prática da afinação:
  1. 1ª corda (MI) ou Mizão: Pulamos a primeira no momento. Veja porque adiante.
  2. 2ª corda (): Para afinar seu violão, comece da 2ª corda (a segunda de cima para baixo). Ela precisa de uma referência externa, normalmente pode-se utilizar o som da chamada do telefone, que é de 440 hz. Uma vez afinada, vá para a terceira corda.
  3. 3ª corda (): Basta posicionar o dedo no 5º traste da 2ª corda, e equiparar os sons da 2ª corda com a 3ª corda solta. Quando os ouvidos indicarem que são similares, está afinada. Passa-se á quarta corda.
  4. 4ª corda (SOL): A 4ª corda deve ter som similar à 3ª corda () tocada no 5º traste.
  5. 5ª corda (SI): É similar em som à 4ª corda (SOL), no 4º traste.
  6. 6ª corda (MI): ou Mizinha, tocada solta tem o som da 5ª corda (SI) tocada presa no 5º traste.
  7. 1ª corda (MI): ou Mizão, é a corda inicial (ou superior) do violão. Tocada solta tem o som da última corda (a 6ª corda ou mizinho) porém uma oitava abaixo. Mesmo sem entender oitavas, o ouvido humano é capaz de identificar estes dois sons como "semelhantes"! Pronto, violão afinado!

War I - A segunda destruição dos exércitos brancos

Pois é... Eu e o Heck aqui na páscoa dos entediados, resolvemos criar algumas regras para se jogar war com apenas duas pessoas. Chegamos às seguintes condições:

  • Cada pessoa irá liderar duas cores
  • Cada cor terá seu próprio objetivo. O jogador ganha se (e quando) conquistar ambos AO MESMO TEMPO.
  • As peças de cores diferentes, chamadas aliadas, terão sua própria vez de jogar, sua contagem de peças é independente, e poderá atacar quem desejar, exceto as aliadas.
  • É possível, ao final da rodada, remanejar as peças por territórios aliados.
  • Territórios que contém ambas peças durante a contagem de territórios não são considerados.
  • Existem duas fases de remanejamento: ao início da rodada, apenas as peças que estão em territórios com duas cores podem ser movidas. Ao final da rodada, o remanejamento normal do war.
  • As cartas são ganhas para o jogador, não para a cor. O jogador guarda as cartas e decide quando realizar as trocas. Pode realizar as trocas no início da jogada de qualquer de suas duas cores.
  • Quando atacado, um território que possuir mais de duas cores pode escolher com qual cor quer se defender. O número de dados é independente e relativo àquela cor escolhida.

Para a alegria dos leitores, o Heck, novamente com suas peças brancas, e agora também com as azuis, teve seus objetivos assim delineados: destruir as peças pretas (hum... coitado...) e conquistar 24 territórios (porque ele tirou destruir as azuis, que já eram dele, e o objetivo alternativo foi acionado).

Meus dois objetivos, coincidência desta vez não atribuída a algum "camaço", era: 1- destruir o Heck (peças brancas) e 2- américa do sul, europa, e outro continente à sua escolha.

América do Sul, com poucas jogadas, foi dominada pelas pretas. América do Norte, com um pouco mais de trabalho, mas com a performance intocável de apenas uma jogada! (sim apenas uma), saiu na frente e foi conquistada.

A Europa foi atacada vinda da Groelandia, também tentando manter Moscou, e entrando da América do Sul, pela África, além do último suspiro, vindo de Vladvostok, até Moscou, para ajudar. Neste caminho, lógico, foi preferido territórios pelos quais estavam os brancos.

A África foi um caso à parte. Madagascar sobreviveu impotente a vários ataques, pecinha isolada, que nada tinha a ver com o objetivo e o caminho global. Ao final do jogo, se tornou ponto principal, pois ali estavam, no continente africano, quase dominando e ganhando suas peças, os brancos! Heck viu aquela pecinha isolada de Madagascar crescer e lhe impor a desesperada derrota.

A definitiva derrota ocorreu na última peça branca, na Polônia. A Polônia, além de ter a última peça branca, era também o último território a conquistar para cumprir o objetivo de ter domínio da América do Sul, Europa, e outro à sua escolha (no caso, a América do Norte).

Sendo assim, os poloneses viram sua destruição como o início de um novo mundo, dominado pelas peças pretas, um ditador insaciável e sanguinário, que não fosse o jogo acabar, teria seguido friamente para destruir as azuis até o fim da Austrália!

Momentos antes da batalha final da Polônia, é importante deixar registrado, o Oriente Médio manteve, com inicialmente 4 peças azuis e duas brancas, uma pequena resistência. Ao ser atacado, primeiro jogou 3 dados contra os invasores de Moscou, e perdeu três peças azuis. No segundo ataque, as peças brancas foram escolhidas, e o defensor jogou 2 dados amarelos. Perdendo as duas peças, sobrou somente uma azul no território. Ficou ele surpreso ao notar que o ataque de Moscou deixou o território com aquela única azul para se dirigir à Polônia e terminar o jogo! Foi ali que ele percebeu: a casa caiu para as brancas! Ahahahaha!

War I - A estréia

Compramos um jogo de war em 3 amigos. No jogo de estréia, um deles não estava presente e mandou um representante, o cientista pinel. Heck, presente, jogou com as brancas, oficialmente suas peças. Eu, com as pretas.


Objetivos: tenho que confessar que não resisti e fiz um "camaço" de modo que os objetivos ficassem mais interessantes. Eu peguei destruir as brancas; Heck, destruir as vermelhas; Pinel, destruir as pretas. A sorte estava lançada... Ahahaha!

Ao final do jogo, repare na peça branca no japão, sendo ameaçada por uma invasão vinda de Vladivostok, que começou lá em Otawa, passou 3 peças para o Alaska, passou duas para Vlad, e uma única legião atacou e dizimou o Alaska, varrendo do mapa a ameaça branca!

Ahahaha!

Tuesday, April 19, 2011

Felicidade

" Como todos sabem
o animal mais inteligente
que existe é o cachalote.
Ele não vai à lua porque
apenas quer ser feliz
e também (confesso) não tem
o dedo polegar.
Mas basta ouvir uma só vez
a Nona de Beethoven,
ou as obras completas de Lennon &
McCartney,
ou o Ulisses,
ou os Elementos de bibliologia,
que sua mente computaplexa
armazena tudo e reproduz nota por
nota, palavra por
palavra, a qualquer momento,
pelo resto da vida."
(Âmbar gris, Rubens Fonseca)

Thursday, April 7, 2011

BrainForce

A definição da linguagem:

Acabo de criar uma linguagem, chamada de BrainForce, desenvolvida baseada nas definições da linguagem de Urban Muller.

A linguagem basicamente tem 8 comandos:

  1. '+' : adiciona um à célula na posição do ponteiro
  2. '-' : subtrai um da céluna na posição do ponteiro
  3. '>' : move o ponteiro para a direita uma casa
  4. '<' : move o ponteiro para a esquerda uma casa
  5. '[' : inicia um laço se o valor na posição do ponteiro for diferente de zero, pula o laço caso contrário
  6. ']' : fecha o laço, retornando o controle para o colchete respectivo que o abriu
  7. '.' : imprime um valor na saída padrão
  8. ',' : lê um valor da entrada padrão
Além desses comandos, é possível utilizar um comando de debug '#' que permite imprimir de uma só vez o valor de cada uma das dez primeiras células (na versão 2.0, isso será variável, imprimindo os 11 valores centrados no ponteiro, 5 a sua esquerda e 5 a sua direita, além do próprio).

Nos comentários do arquivo de definição do analisador léxico se encontram essas explicações (o programa foi todo codificado em inglês, para melhor aceitação da comunidade internacional, incluindo comentários e nomes de variáveis):
/*
BrainForce Compiler v.1.0, An esoteric programming language
Author: Ruben Carlo Benante (Dr. Beco)
Email: rcb [at] beco.cc
Creation date: 05/Apr/2011
Project based on the ideas of Urban Muller (http://fi.aminet.net/dev/lang)
WebPage: www.beco.cc/compiler/brainforce
License: CC-3.0 http://creativecommons.org/licenses/by-nc-sa/3.0/

Usage:
./brainforce input_file [-o output_file] [options]

input_file : a input file with source code in BrainForce language (.bf)
output_file : a generated C source code from the input file (.c)

Options:
-zn :
n=0 default behavior
n=1 set zero = '0' for pretty print of chars
n=2 set cells to read/write integers
-d : print the syntax tree of the input_file
-v : verbosity mode. Can pile up till level 10
-q : quiety mode
-E : stop after preprocessor and write output_file.i (not implemented)
-S : stop after assembler and write output_file.s (not implemented)
-C : stop after C generator and write output_file.c (default)
-o file : output file name (default .c)
-h : print this help

BrainForce Source File:
Command Meaning
> increment the data pointer (to point to the next cell to the right).
< decrement the data pointer (to point to the next cell to the left).
+ increment (increase by one) the byte at the data pointer.
- decrement (decrease by one) the byte at the data pointer.
. output a character, the ASCII value of which being the byte at the data pointer.
, accept one byte of input, storing its value in the byte at the data pointer.
[ if the byte at the data pointer is zero, then jump forward to the command after the matching ] command.
] if the byte at the data pointer is nonzero, then jump back to the command after the matching [ command.
# debug: print the first 10 cells
*/


A linha de comando:

O compilador chamado de
 brainforce
é chamado na linha de comando com a syntaxe e opção dos seguintes argumentos:

uso:

$./brainforce arquivoentrada.bf [-o arquivosaida.c] [opções]


As opções disponíveis são:

-zn :
n=0 comportamento padrão compatível com a definição da linguagem original
n=1 faz o zero = '0', valor ASCII 48, para imprimir caracteres de modo mais legível
n=2 usa inteiros nos comandos de ler ',' e imprimir '.'
-d : imprime a árvore de sintaxe gerada pelo compilador
-v : aumenta a saída de mensagens de compilação. Pode ser usada de 1 a 10 vezes
-q : ativa o modo silencioso, diminuindo as mensagens de compilação
-E : roda apenas o preprocessador com arquivo de saída arquivo.i (não implementado)
-S : roda apenas o assembler, dando saída ao código assembly arquivo.s (não implementado)
-C : traduz o código do Brain Force para linguagem C na saída arquivo.c (é o modo padrão)
-o nome_arquivo : nome do arquivo de saída (sem definir, imprime na saída padrão,
-h : imprime esta ajuda


Como se pode ver, são muitas opções. Mas o mais impressionante é que esta pequena linguagem é Turing-Completa. Ou seja, é capaz de fazer qualquer coisa que as atuais linguagens mais poderosas do existentes, basta você ter muito tempo, e não ter vida social nenhuma.

Sunday, April 3, 2011

Mini Cliente em C

Este é um exemplo de código para um cliente mínimo, que envia um byte (letra C) para o servidor, e lê outro byte do servidor, pela internet. As tarefas para se conseguir isso são realizadas na ordem:

  1. Creating socket... done!
  2. Connecting... done!
  3. Writing "C"... done!
  4. Reading... "S" done!
Abaixo o código:

/*
Program: mincli.c
Author: Dr Beco
Date: 2001-04-03
Objective:
show a minimum client program that can
connect to a network, write a byte, read a byte, disconnect
*/

#include <stdio.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netdb.h>

#define BUFFER 2

int main(void)
{
printf("Configuring environment... ");

char data[BUFFER];
const char *host_server="localhost";
struct sockaddr_in dir;
struct hostent *host;
int aux, id, p=3333; //port

dir.sin_port = p;
dir.sin_family = AF_INET;
host = gethostbyname(host_server);
if(host == NULL)
return -1;
dir.sin_addr.s_addr = ((struct in_addr *)(host->h_addr))->s_addr;
printf("done!\n");

printf("Creating socket... ");
id = socket(AF_INET, SOCK_STREAM, 0);
if(id == -1)
return -1;
printf("done!\n");

printf("Connecting... ");
if(connect(id, (struct sockaddr *)&dir, sizeof(dir)) == -1)
return -1;
printf("done!\n");

printf("Writing \"C\"... ");
aux = send(id, "C", 1, MSG_NOSIGNAL);
if(aux < 0)
return -1;
printf("done!\n");

printf("Reading... ");
aux = read(id, data , 1);
if(aux!=1)
return -1;
printf("\"%c\"", data[0]);
printf(" done!\n");
return 0;
}

Mini Servidor em C

Este é um exemplo de código para um servidor mínimo, que lê um byte (letra) e envia outro byte (letra S) pela internet. As tarefas para se conseguir isso são realizadas na ordem:

  1. Configuring environment... done!
  2. Creating socket... done!
  3. Configuring socket... done!
  4. Binding... done!
  5. Listening... done!
  6. Accepting... done!
  7. Reading... "C"done!
  8. Writing "S"... done!

Abaixo o código:
/*
Program: minser.c
Author: Dr Beco
Date: 2001-04-03
Objective:
show a minimum server program that can
create a socket, accept a client, read a byte, write a byte, disconnect
*/

#include <stdio.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/un.h>

#define BUFFER 2

int main(void)
{
printf("Configuring environment... ");

int p = 3333; // port
char data[BUFFER];
struct sockaddr_in dir;
struct sockaddr client;
socklen_t long_client;
int id, idReuse=1, son, aux;

memset(&dir,0,sizeof(dir));
dir.sin_port = p;
dir.sin_family = AF_INET;
dir.sin_addr.s_addr = INADDR_ANY;
printf("done!\n");

printf("Creating socket... ");
id = socket(AF_INET, SOCK_STREAM, 0);
if (id == -1)
return -1;
printf("done!\n");

printf("Configuring socket... ");
if(setsockopt(id,SOL_SOCKET,SO_REUSEADDR,&idReuse,sizeof(idReuse))==-1)
return -1;
printf("done!\n");

printf("Binding... ");
if(bind(id, (struct sockaddr *)&dir, sizeof(dir)) == -1)
{
close (id);
return -1;
}
printf("done!\n");

printf("Listening... ");
if (listen(id , 1) == -1)
{
close(id);
return -1;
}
printf("done!\n");

printf("Accepting... ");
long_client = sizeof (client);
son = accept(id, &client, &long_client);
if (son == -1)
return -1;
printf("done!\n");

printf("Reading... ");
aux = read(son, data , 1);
if(aux!=1)
return -1;
printf("\"%c\" ", data[0]);
printf("done!\n");

printf("Writing \"S\"... ");
aux = send(son, "S", 1, MSG_NOSIGNAL);
if(aux < 0)
return -1;
printf("done!\n");

return 0;
}