A 11ª edição da FEBRACE (Feira Brasileira de Ciências e Engenharia) acontece de 12 a 14 de março, nas dependências da Escola Politécnica da Universidade de São Paulo (Poli-USP), em São Paulo. Ela contará com 330 projetos realizados por estudantes do ensino básico de 25 estados brasileiros e do Distrito Federal.

• Inclua um  kernel de elementos amplamente definidos, extensível para usos específicos;
• Aborde tanto questões de tecnologia quanto de pessoas;
• Seja suportada pela indústria, academia, pesquisadores e usuários e
• Tenha suporte a extensões em face da mudança dos requisitos e da tecnologia.

O servidor onde estou rodando o projeto (Linux) tem uma configuração um tanto quanto diferente do meu Mac. Com isso, algumas coisas que rodam aqui não rodam lá e vice e versa.

Como não tenho saco para compilar uma versão similar do PHP na unha pra sobre escrever o que vem no Mountain Lion, nem de ficar editando o httpd.conf pra deixar as permissões de acesso corretas, muito menos pra achar uma VM e reinstalar um LAMP similar, acabei optando por testar as coisas diretamente no servidor.

Os CyberDuck, programa de FTP que tenho utilizado é bem espertinho e, com um duplo clique no arquivo remoto, o mesmo já abre no TextMate 2. Quando salvo no TM2, ele automaticamente vai para o servidor.

Tudo ótimo, tirando o fato de que tudo que altero remotamente precisa ser baixado para minha máquina, manualmente, para que eu tenha cópias locais e faça o versionamento via SVN.

Além disso, como o produto está tomando proporções maiores, nem sempre usar o TextMate 2 é a melhor opção, principalmente no momento em que começo a cogitar o uso de frameworks para desenvolver. Então, parti pro NetBeans, que, por si só, já faz sincronização automática via FTP, mas, caso eu edite uma linha de código fora dele, isso já falha.

Começa a busca…

Dessa forma, fui atrás de uma solução grátis que fizesse exatamente o seguinte:

1. Identificar que um arquivo foi alterado
2. Subir APENAS o arquivo alterado para o servidor remoto
3. Me avisar que o processo está concluído e eu já posso apertar CMD+R (o F5 do Mac)

Encontrei várias menções ao “WinSCP“, cliente de FTP que promete fazer isso, mas, como o nome já diz, ele é exclusivo para Windows.

Depois, lí que o “Transmit“, cliente de FTP pra Mac também fazia. Baixei um trial, e descobri que ele falhava no quesito 1, não identificando alteração dos arquivos.

Aí, descobri que existe um comando no terminal chamado “rsync“, que faz o 2, mas nem sonha com o 1.

Vários foruns e StackOverflows depois, vi gente sugerindo loop infinito de rsync como “solução” para a sincronização em tempo real. Como bom nerd, me recuso a achar que loop infinito executando de 5 em 5 segundos é “tempo real”!

Enfim, depois de um fim de semana pesquisando, consegui montar um “set” de programas para fazer exatamente o que eu queria e, até o momento, tudo está funcionando exatamente como eu queria!

A solução “mágica”, porém complexa

Vamos lá, amiguinhos… primeiro, os “ingredientes” para nossa mágica:

• SSH Passwordless Login – essa solução só funciona se você conseguir se logar via SSH sem o uso de senha. Nem todo servidor aceita isso!
• rsync – acho que vem por padrão no Shell de todo Unix
• HomeBrew – primo Macintóshico do aptitude de Linux
• Watchdog – utilitário em Python que verifica se um arquivo foi alterado
• Terminal Notifier – utilitário em Ruby que manda uma mensagem para o Notification Service do Mac. Não sei se existe algo similar para Linux
• Criação de dois Shell Script para serem facilmente executados

Agora, ao passo a passo…

SSH Passwordless Login

Para conseguir fazer o login sem uso de senha via ssh, digite os seguintes passos no Terminal:

ssh-keygen -t rsa

Digite enter três vezes para aceitar os valores padrão. Isso irá criar uma chave de acesso da sua máquina.

Acesse seu servidor via FTP e crie uma pasta chamada .ssh (atenção com o ponto). Dentro dela, crie uma pasta chamada authorized_keys.

Copie a chave que foi criada para dentro da pasta authorized_keys.

Dessa forma, terá a seguinte estrutura na raiz do seu usuário FTP:

/.ssh/authorized_keys/id_rsa.pub

Agora, precisamos alterar as permissões desse arquivo. Dá pra fazer isso pelo programa de FTP ou via ssh + comando chmod.

A pasta .ssh deve ter permissões 700, isto é, dono do arquivo pode ler, escrever e executar.

A pasta authorized_keys deve ter permissão 600, isto é, o dono do arquivo pode ler e escrever, mas não executar.

Feito isso, experimente logar no seu servidor via ssh, pelo terminal:

ssh seu_usuario_de_ftp@seu_servidor.com

Verifique que não deve ser pedida senha… você simplesmente acessa, pois o servidor já tem uma autorização para seu computador (se fizer isso de outro local, a senha será pedida).

rsync

Se você conseguiu acessar o servidor sem usar senha, provavelmente todo o resto irá funcionar corretamente.

Para começar, vamos testar o rsync, para garantir que estamos sincronizando as pastas corretas e excluindo os arquivos corretos dessa sincronização (.svn, .git, .log etc.).

Para o teste, crie uma nova pasta no seu servidor, assim evitamos destruir seu site

Crie também uma pasta vazia no seu computador e digite o seguinte no Terminal:

rsync -azP --delete --exclude .svn --exclude .git --exclude .DS_Store --exclude .cvs --exclude '/cache' --exclude '/logs' ~/pasta_vazia_a_ser_sincronizada/ seu_usuario_de_ftp@seu_servidor.com:pasta_vazia_que_voce_criou_no_servidor/

• -azP – não lembro o que significam, mas acho que tem a ver com subir apenas o que foi modificado
• –delete – o que você deletar na sua máquina também será excluído do servidor
• –exclude – tudo que você não quer que seja sincronizado
• ~/pasta_vazia_a_ser_sincronizada/ – o caminho para a pasta do seu computador
• seu_usuario_de_ftp@seu_servidor.com:pasta_vazia_que_voce_criou_no_servidor/ – conexão SSH com seu servidor. Depois dos “dois pontos”, é o caminho da pasta que será sincronizada

Coloque um arquivo de texto na sua pasta vazia e execute o comando… observe a mágica.

Agora, edite algo nesse texto, e execute o comando novamente.

Se tudo deu certo, depois de executar o comando, o arquivo é enviado ao servidor!

HomeBrew

Provavelmente o mais chatinho de instalar, já que precisa do GCC para ser compilado e, normalmente, se consegue o GCC instalando o IMENSO X-Code.

Mas, depois de instalar o IMENSO (não canso de repetir) X-Code, basta digitar o seguinte no Terminal.

ruby -e “$(curl -fsS http://gist.github.com/raw/323731/install_homebrew.rb)”
brew update

Watchdog

Com o HomeBrew devidamente instalado e atualizado, vamos adicionar uma dependência do Watchdog. Digite no Terminal:

brew install libyaml

Agora, vamos baixar o Watchdog. Basta digitar no Terminal:

sudo easy_install watchdog

Não vamos testá-lo agora, mas só depois, com a criação de um Shell Script.

Terminal Notifier

Finalmente, o não necessário, mas bastante importante notificador.

Como é um script Ruby, basta digitar o seguinte:

sudo gem install terminal-notifier

Após a instalação (bem rápida), teste se ele está funcionando:

terminal-notifier -message "Starting sync"

Se a janelinha de notificação do Mac apareceu, é porque funcionou!

Shell Script de verificação de atualização

Primeiro, vamos criar um Shell Script que sera nosso verificador.

Crie um novo arquivo de texto e digite o seguinte nele:

watchmedo shell-command \
	--patterns="*.php;*.js;*.css" \
	--recursive \
	--command='~/endereco_do_outro_script/FolderSync.sh' \
	.

Preste atenção nos espaços, na barra invertida e no ponto no final!

• –patterns – define que tipo de arquivo que observar mudanças
• –recursive – além da pasta inicial, olha todas as subpastas
• –command – define o que você quer executar quando uma mudança for observada. Aqui, iremos executar o outro Shell Script, que executa o rsync e envia os alertas pro Mac.

Salve esse arquivo com a extensão “.sh”. Vamos chamá-lo de “FolderWatch.sh”.

Shell Script de sincronização e alerta

Crie um outro arquivo de texto com o seguinte:

#!/bin/bash
# Synchronization script
terminal-notifier -message "Starting Site sync"
rsync -azP --delete --exclude .svn --exclude .git --exclude .DS_Store --exclude .cvs --exclude '/cache' --exclude '/logs' ~/pasta_local_do_site_a_ser_sincronizado/ seu_usuario_de_ftp@seu_servidor.com:pasta_do_seu_site
terminal-notifier -message "Sync has finished"

Salve esse arquivo no caminho que você definiu no outro arquivo, o “FolderWatch.sh”

Agora, pelo terminal, vá até a pasta que deve ser sincronizada e execute o “FolderWatch.sh”.

~/caminho_do_folder_watch/FolderWatch.sh

Na minha máquina, sempre dá um alerta quando executo isso, mas aparentemente, nenhum problema acontece:

/Library/Python/2.7/site-packages/argh-0.22.0-py2.7.egg/argh/completion.py:84: UserWarning: Bash completion not available. Install argcomplete.

Agora, edite um arquivo do seu site e veja a mágica ocorrendo!

Imediatamente aparece a mensagem do Mac e, no terminal, a mensagem “* Notification delivered.”. Depois disso, o rsync executa e tudo que você alterou é enviado ao servidor.

Criando links dos Shell Scripts

Apenas para facilitar um pouco a vida, você pode criar links dos Shell Scripts para a pasta /usr/bin, de forma que eles sejam acessados sem precisarmos digitar o endereço completo deles:

ln -s ~/caminho_do_folder_watch/FolderWatch.sh /usr/bin
ln -s ~/caminho_do_folder_sync/FolderSync.sh /usr/bin

Finalmentes…

Deu um trabalho do cão descobrir tudo isso, mas realmente facilitou minha vida e agora eu durmo tranquilo sabendo que meu computador e meu servidor estão realmente espelhados!

Eu postei essa solução originalmente no StackOverflow, aqui e aqui

Se gostou, dá um up lá!

Objetivo

O Sistema de Apoio ao Diagnóstico Médico foi construído com o intuito de gerar sugestões de diagnóstico médico a partir de dados de sintomas e exames realizados anteriormente, fornecidos pelo médico durante a consulta. Conforme uma necessidade apresentada por médicos, o sistema foi se adaptando para a determinação de meta para um tratamento de Diabetes.

Motivação

As soluções de auxílio a diagnóstico médico já são utilizadas no exterior, pois, com cada vez mais dados disponíveis na Internet, torna-se atrativo o uso de sistemas que utilizam esses dados para melhorar o conhecimento dos médicos. Estas soluções variam quanto à linguagem, algoritmos e especificidade, sendo difícil realizar comparações entre os mesmos.

A motivação para se utilizar esse tipo de sistemas é a possibilidade de manipulação de grande quantidade de variáveis envolvidas para o diagnóstico de uma doença, além da existência de grande número de doenças existentes.

No entanto, o desenvolvimento destes sistemas não tem a intenção de substituir os médicos e sim de fornecer a eles informações e novas visões para realizar o diagnóstico. A decisão final é do médico já que um sistema computacional é limitado a uma série de decisões e regras pré-determinados.

Diabetes

O Diabetes é uma doença comum, que causa aumento do nível de açúcar no sangue. Normalmente, o sangue possui certa quantidade de glicose, vinda dos alimentos, que o organismo utiliza para gerar energia. Para o organismo utilizar a glicose, é necessário um hormônio chamado insulina, que é produzido pelo pâncreas. A doença é causada pela diminuição da produção  ou ação não eficiente da insulina.

Uma das principais metas no controle do diabetes  é a manutenção do nível de hemoglobina glicada, também denominada hemoglobina glicosada ou glicohemoglobina, abaixo de 7%.

No entanto, essa meta terapêutica pode variar conforme alguns fatores como, por exemplo, a idade do paciente e a duração da doença. Quando esses fatores não são considerados, podem ocorrer casos de hipoglicemia, além de aumentar os riscos de arteriosclerose vascular em pacientes mais idosos, devido à agressividade do tratamento.

Dessa forma, a partir de parâmetros como idade e tempo de doença, o SADM calcula o novo valor sugerido da meta do exame do nível de hemoglobina glicada ideal do paciente, como mostra a tabela simplificada a seguir:

Tabela simplificada de parâmetros para a determinação de meta para o tratamento de hemoglobina glicada

Exemplo de cupom gerado pelo Bom Cupom

O Projeto

O nosso projeto de formatura consiste no desenvolvimento de um sistema que vai analisar os hábitos de consumo dos clientes de um supermercado e através de técnicas de data mining gerar cupons promocionais personalizados a cada cliente, o Bom Cupom.

Um procedimento já bem difundido que foi explorado durante o projeto é a análise de carrinho de compras, que permite a inferência de correlação entre a compra de diferentes produtos. Podemos, por exemplo, deduzir que um cliente que compra muito pão deve também comprar manteiga (e outras implicações não tão evidentes com grande valor estratégico).

Desta maneira visamos atender a interesses dos clientes e dos vendedores. Os clientes obteriam preços diferenciados em produtos especialmente selecionados de acordo com seu padrão de compras. E os supermercados estariam oferecendo tratamento personalizado e desta forma ganhando a preferência e confiança dos consumidores.

Motivação

O relacionamento com o cliente é, sem dúvida, um fator muito importante para o sucesso de um negócio. Clientes satisfeitos tornam-se fiéis e possivelmente defensores de uma marca. E para satizfazer os clientes é importante entender seus hábitos e costumes.

Hoje em dia, empresas já estão gerando uma grande quantidade de informação sobre seus clientes. E a utilização de técnicas de data mining, combinada com essa informação inexplorada já existente atualmente é um fator decisivo na estratégia de marketing de uma empresa.

Além disso, técnicas de data mining são uma ferramenta poderosa de análise de dados e seu estudo aprofundado agrega um conhecimento muito importante não só para este projeto de formatura, como também para projetos futuros.

O Sistema

O sistema foi dividido basicamente em quatro módulos:

Divisão do sistema em módulos

Classificação em Avatares

Já que existe uma grande variedade de produtos oferecidos por um supermercado, a primeira etapa é a padronização e classificação destes produtos em classes, chamadas de avatares.

Esse agrupamento é necessário para aumentar a relevância dos resultados obtidos. Com isso desconsideramos informações muito específicas de um produto como peso, volume, marca, entre outros, ou seja, é aquilo que você escreveria em sua lista de compras.

Por exemplo, um produto que estaria especificado no banco de dados do supermercado como “DETERGENTE YPÊ NEUTRO 500ml LÍQUIDO” seria classificado como “DETERGENTE” simplesmente.

Com a informação do código de barras dos produtos, foi usada a API do Buscapé, que já fornece uma classificação primária de muitos produtos cadastrados em lojas brasileiras e ainda pode fornecer uma descrição mais detalhada do que a que temos inicialmente. Porém, nem todos os produtos puderam ser classificados com esse método e para a classificação dos restantes foram utilizadas técnicas de comparação de strings como Longest Common Subsequence e distância de Levenshtein.

Regras de Associação

Grafo de regras de associação

Com os produtos classificados, este módulo tem como objetivo gerar regras de associação entre os avatares, definindo um modelo global de hábitos de compra para o supermercado. Com este modelo é possível definir a correlação de compra entre produtos, como por exemplo, quem compra pão deve também comprar manteiga.

Weka

Nesta etapa foram utilizados algoritmos de geração de regras de associação oferecidos pela ferramenta de data mining da Universidade de Waikato, Weka. Com a definição de certos parâmetros, foi possível obter as regras de associação mais relevantes de acordo com uma série de métricas também oferecidas pelo framework.

Modelo de Cestas Básicas

Para poder oferecer descontos personalizados, é preciso também modelar os hábitos individuais de cada cliente. E para isso precisamos primeiramente dividir os produtos entre categorias de preço.

Para a divisão entre categorias de preço foram utilizadas predominantemente técnicas estatísticas e cada produto foi então classificado em uma de três categorias (chamadas de margem): econômica, intermediária e premium.

Com isso, foi definido o modelo de cestas básicas. Para cada cliente do supermercado foi criada uma cesta básica que contém um item descrevendo cada produto (avatar) já comprado. Esses itens possuem três atributos:

• Nome do avatar
• Margem predominante
• Índice de recompra

O índice de recompra é determinado também através de análise estatística das compras anteriores e define a probabilidade de que este cliente compre o produto novamente numa visita futura. Definimos assim o perfil individual de compras de cada cliente.

Geração de Cupons

Definidos todos os modelos, os cupons de desconto são gerados seguindo três políticas, que podem ser aplicadas conforme a conveniência:

Política de fidelização: é oferecido desconto em um produto que o cliente já costuma comprar com o intuito de fazer com que ele sinta-se privilegiado com um desconto em seu produto favorito.

Política de upgrade de marca: é oferecido desconto em um produto que o cliente já costuma comprar, porém em uma margem superior com o intuito de fazer com que o cliente experimente outras marcas.

Política de introdução de produto: com uma análise da cesta básica em conjunto com as regras de associação, é oferecido desconto em produtos que o cliente ainda não costuma comprar, mas que seriam muito atrativos, de acordo com o modelo global.

Processo de oferecimento de desconto pela política de introdução de novo produto

—
Essa foi uma breve descrição do nosso projeto de formatura. A monografia completa com a descrição detalhada do projeto e de seu desenvolvimento pode ser baixada aqui. Para os interessados haverá uma demostração prática na sala C1-30 das 9h00 às 17h00 no Prédio da Engenharia Elétrica na Poli, no dia 10 de dezembro.

Para entrar em contato com os membros do grupo:
Bruno Henrique Joia
Gustavo dos Santos Rocha
Igor Yasuo Gushiken

“…Procurei um meio de falar com vc que não fosse esse, mas não encontrei. Não sei se você pode me ajudar, mas não conheço ninguém que cursa ou se formou em Eng da Computação e procurando por informações cai aqui. Estou na dúvida entre cursar Engenharia ou Ciência da computação (respectivamente, POLI e IME) e gostaria de saber mais sobre as diferenças entre os dois cursos na prática e no mercado. Sei que você pode não conhecer sobre o dia-a-dia do curso no IME, mas de qualquer forma acho que qualquer informação de alguém que cursou uma das duas pode ser válido!

Cursei dois anos de Economia e larguei sabendo que queria computação, mas na hora de optar por uma das duas (ainda mais que ciência, agora, é separado de Engenharia na inscrição da Fuvest) fiquei perdido. Tenho olhado a grade e procurado informações, mas sobre o mercado e a vivência nos cursos não encontrei nada…”

Minha resposta, com algumas alterações e adição de alguns links, foi a seguinte:

Sofri bastante quando decidi cursar algo a ver com computação, com essa mesma dúvida: ciências ou engenharia.

Cheguei a criar uma comunidade no Orkut para me ajudar nessa decisão! Ainda é uma comunidade interessante (apesar de eu não entrar mais, nem cuidar dela) e tem vários tópicos sobre o assunto.

Mas, independente de outras opiniões que vc possa encontrar nesses tópicos, aí vai a minha.

Obviamente que posso falar com muito mais propriedade sobre Engenharia do que sobre Ciências, mas, vamos lá.

Ciências é um curso bem forte caso você queira desenvolver software. Você aprenderá as entranhas, o planejamento, a construção… provavelmente verá várias linguagens de programação e aprenderá profundamente algumas delas. Entenderá como solucionar diversos problemas usando e criando algorítmos e terá uma base matemática bem forte.

Engenharia é um curso mais generalista (na Poli, em específico) e você terá uma visão mais macro do computador. Terá várias matérias não relacionadas a computação, exatamente pelo generalismo da Poli.

Aprenderá muita lógica, mas não será nenhum mestre de programação (se depender da faculdade) em uma linguagem específica. Entenderá todas as entranhas de um sistema computacional, desde os componentes básicos até o sistema operacional.

Passeando um pouco por um computador, começamos com Laboratório de Fundamentos de Computação, em que programamos um emulador de uma máquina de Von Neuman (é um computador bem básico mas que é a base da computação atual, ignorando a quântica, que mal vimos).

Nessa mesma disciplina, criamos a linguagem de máquina (tipo um assembly, bem básico) dela e escrevemos programas, inicialmente com comandos hexadecimais (0 a 15) e, no fim do curso, com comandos mnemônicos (SUM para somar, por exemplo).

Temos também, Laboratório Digital, em que construímos os mais diversos “equipamentos” eletrônicos usando apenas componentes primários, como portas booleanas (fazem operações lógicas, tipo E, OU…). Começamos com coisas bem simples e, no fim do curso, montamos um mini computador com 16 operações diferentes.

Em matérias teóricas, começamos com Projeto Lógico Digital (essa disciplina, com o excepcional  - minha opinião de merda – professor Edson Fregni,  parece ter mudado de nome… ou não existe mais – não encontrei na grade atual). Nessa disciplina, entendemos o funcionamento dos componentes básicos e alguns mais avançados, todos necessários para o entendimento de um computador.

A sequência dessa é Organização de Sistemas Digitais, em que, a partir dos componentes que conhecemos na anterior, aprendemos a organizar um sistema a fim de montar om computador. Aprendemos um troço chamado VHDL (ou não) que é uma linguagem de construção de sistemas eletrônicos. Seu funcionamento é bem diferente das linguagens de programação normal, pois nela as coisas não são, necessariamente, sequenciais. Várias coisas podem acontecer paralelamente.

Depois disso, temos Arquitetura de Computadores e entendemos mais a fundo como funciona um computador de verdade. Desde o controle de um disco até a apresentação de dados numa tela. Nessa, temos também uma base de assembly (vimos assembly de ARM no nosso ano, mas pode ser de x86, x64 etc.).

Junto de Arquitetura, temos o Lab. de Processadores. Nele, programamos em assembly (era de Motorora 6800, mas já deve ter migrado pra ARM). É a prática e programamos desde coisas bem simples até drivers de comunicação entre o computador e um display.

Depois, temos Sistemas Operacionais e entendemos como um “programão” controla tudo o que aprendemos nas outras disciplinas. Usamos um sistema operacional didático chamado Minix para entender como um SO funciona. Mexemos nas entranhas dele e vemos como as coisas funcionam (e como são complicadas).

Finalmente, Linguagens e Compiladores nos dá a base para entender como uma linguagem de programação é criada (nós criamos uma) e como um compilador funciona (criamos um que interpretava a nossa linguagem). A matéria mistura bem teoria e prática e é considerada o terror dos terrores, já que envolve diversos conceitos muito teóricos. Nessa matéria você descobre a mágica das expressões regulares.

Agora, falando em Software, temos diversas matérias que vão desde as teorias de desenvolvimento (cascata, circular etc), banco de dados, documentação e o desenvolvimento propriamente dito.

A matéria Laboratório de Engenharia de Software II é o que você coloca em prática tudo que aprendeu nas outras disciplinas. No nosso ano, fizemos um ERP modularizado e cada grupo de 4 alunos fez uma parte. Tinhamos que escolher a linguagem de programação (cada grupo podia usar a sua), a arquitetura e divisão do software como um todo, a forma de comunicação de cada módulo com os outros (usamos SOAP no nosso grupo), a documentação que seria produzida e a interface do sistema.

Além disso, no fim do curso tivemos algumas disciplinas sobre empreendedorismo (optativa mas imperdível) (mais uma que, infelizmente, deve ter se aposentado junto do professor Edson Fregni… uma pena), segurança (sentido “security”), inteligência artificial e multimídia.

Outras que valem ser citadas são segurança (sentido “safety”), controle (que usa computação em praticamente tudo, hj em dia) e redes de computadores.

Além disso, tem um monte de outras matérias que não tem nada a ver com computação mas que te ajudam a se formar um engenheiro que, na minha visão, é um “resolvedor de problemas”.

Em relação ao mercado, ambos são bem remunerados e com muita vaga disponível pra quem é bom. Escolhi engenharia por me ver com um perfil não tão técnico. Amo tecnologia, amo computação, mas gosto mais do fim do que do meio e acho que a engenharia dá uma visão mais generalista e acaba sendo um caminho mais natural pra quem não quer escovar bits.

Ao término deste tutorial, todos os demais dispositivos da sua rede em casa que possuam suporte ao IPv6 conseguirão conectar-se à internet via IPv6.

Após seguir o tutorial da Parte 1 você já deve  possuir umas das duas configurações abaixo:

• Com roteador doméstico + NAT:

• Computador direto na internet com IPv4 público Global Unicast:

Sub rede com ips válidos na internet IPv6

Até alguns meses atrás, após conseguir o túnel pelo site do projeto SIXXS, era necessário manter o túnel ativo por uma semana para conseguir realizar o pedido de alocação de subrede . Porém hoje, todos os usuários que possuem um túnel já possuem também um prefixo de subrede /64 alocado.
Faça o seguinte:

1. Entre no site do projeto SIXXS no endereço www.sixxs.net e faça o login no link Login for Existing Users.
2. Na tela de configurações onde são exibidos os dados do usuário e os túneis haverá também uma tabela com as subredes. Verifique se o prefixo de subrede está ativado, caso contrário, clique no ID da subrede e ative o mesmo.

Pronto. Agora o PoP anuncia a rota na Internet IPv6 dizendo que a sua subrede, por exemplo, 2001:1291:200:8123::/64 é acessível pelo roteador cujo IP é o IPv6 do túnel: 2001:1291:200:123::2.

Anote o Subnet Prefix da sua subrede pois será necessário na configuração do computador como roteador.

Detalhes do IPv6

Antes de configurar o Windows para funcionar como um roteador IPv6 é interessante conhecer uma parte do funcionamento do IPv6.

O IPv6 não implementa broadcast, logo não existe no IPv6 o equivalente a mandar um pacote para o endereço 192.168.1.255 sendo que todos os computadores da sub rede 192.168.1.xxx irão receber o pacote. No IPv6 a funcionalidade do broadcast é feita com multicast.

Mas, para o multicast funcionar as placas de rede devem possuir um endereço IP já atribuído e realizar o join no IP do grupo multicast. Sendo assim como funciona, por exemplo, o DHCPv6 já que não existe broadcast? E o ARP? Para responder isto basta você verificar que todas as suas placas de rede, mesmo antes de começar o tutorial na Parte 1, já possuíam um endereço IP começando com fe80::.

O IPv6 define que os 64 bits mais significativos são usados para definir as redes e os 64 bits menos significativos sejam usados para definir os hosts. Isto mesmo, a recomendação é que para cada usuário final seja fornecido um prefixo IP com 64 bits sobrando para usar nos dispositivos em casa, logo na sua casa você poderá ter 2^64 dispositivos com IPs diferentes todos com IPs reais da internet.

Endereços Link-Local

Todo dispositivo IPv6 possui um endereço IP automaticamente gerado assim que o driver IPv6 é ativado na interface e este endereço IP sempre pertence à rede fe80::/10.
A geração automática dos 64 bits menos significativos é feita automaticamente. Mas como garantir que não haja conflito? A resposta é se basear em algo que já esteja garantido em não conflitar. Se você pensou no endereço da camada de enlace você acertou. O MAC-Address é utilizado na geração automática dos 64 bits menos significativos dos IPs automáticos das placas de rede, porém o MAC-Address possui apenas 48 bits e para gerar 64 bits a partir dele segue-se a receita do padrão EUI-64 que insere os 16 bits 0xFFFE no meio dos 48 bits e inverte o 7º bit mais significativo do valor final.

IPv6 Link-Local gerado automaticamente

Alguns SOs não seguem o padrão EUI-64 para evitar que possa inferido facilmente o MAC Address da interface.

Assim, se você possui outros dispositivos IPv6 na sua rede local e se já compartilhava arquivos pelos compartilhamento do Windows, você já estava usando IPv6.:

Ping de resposta de um computador na rede do Windows

Grupo multicast all-nodes

Agora com todas as placas de rede com endereços IPv6 automaticamente gerados todas elas automaticamente assim que são ativadas realizam o join no grupo multicast all-nodes que representa “todos os dispositivos da camada de enlace”. A implementação do IPv6 definiu este grupo multicast com o endereço ff02::1. Assim, para realizar o equivalente ao broadcast do IPv4 basta enviar um pacote para o grupo multicast ff02::1.

Porém todos estes endereços IPv6 da subrede fe80::/10 são apenas endereços locais que servem para comunicação na rede local e não são endereços válidos na internet . Para os computadores acessarem a internet é necessário um roteador e que as placas de redes todas possuam um endereço válido. A implementação do IPv6 inclui um mecanismo feito para facilitar a configuração de redes IPv6 simples como é o cenário doméstico e que não utiliza necessariamente o bom e velho DHCP.

Router Advertisements

Após ingressar no grupo multicast os dispositivos enviam um pacote ICMPv6 do tipo Router Solicitation para o grupo multicast all-routers, ff02::2, e os roteadores que estiverem configurados respodem com o pacote Router Advertisement que informa o seu endereço IPv6 e qual o prefixo dos 64 bits superiores que a placa de rede deve usar para a autoconfiguração. Este funcionamento difere do DHCP pois não há a necessidade de configurar no roteador um intervalo de IPs.

Com o 64 bits superiores  a placa de rede gera os 64 bits inferiores usando o padrão EUI-64 e registra o endereço IPv6 do roteador que respondeu com o Router Advertisement como gateway para a internet. Assim a placa de rede conterá dois IPs. Um endereço link-local e um endereço real.

IPv6 após a resposta do gateway com Router Advertisement

O mecanismo acima descrito é chamado de Stateless Address Autoconfiguration em contraste com o uso do DHCPv6 para alocação de endereços IPv6 que é chamado de Stateful Configuration.

Se você quiser aprender mais sobre o IPv6 principalmente com relação ao serviços que usam o grupo multicast Link-Local recomendo o mini curso de IPv6 em flash do site www.ipv6.br. É extremamante didático e o capítulo Serviços Básicos do IPv6 foca nos pacotes ICMPv6 usados, por exemplo, no Router Advertisement e Router Solicitation.

Configurando o Windows 7/Vista para funcionar como um gateway IPv6

Basta agora configurar o Windows para encaminhar pacotes e respoder à pacotes Router Solicitation. Tenha em mãos o seu Subnet Prefix e o nome da conexão local usada para comunicar com os outros computadores da rede interna, por exemplo, “Conexão Local 1″ ou “Local Connection 2″.  Abra o Prompt de Comando como Administrador e digite :

1) netsh interface ipv6 add route [Seu Subnet Prefix]/64 [Nome da conexão local] publish=yes

Isto irá definir um endereço IPv6 real com o seu prefixo alocado pelo PoP  à sua placa de rede.

2) netsh interface ipv6 set interface [Adaptador virtual do túnel] forwarding=enabled

Isto irá ativar o encaminhamento de pacotes no adaptador de rede virtual do túnel 6in4.

3) netsh interface ipv6 set interface [Nome da conexão local] forwarding=enabled advertise=enabled
Irá ativar o envio de Router Advertisements na rede local.

Exemplo com os dados do início do post:

1) netsh interface ipv6 add route 2001:1291:200:8123::/64 “Conexão local 1″ publish=yes

2) netsh interface ipv6 set interface “sixxs” forwarding=enabled

3) netsh interface ipv6 set interface “Conexão local 1″ forwarding=enabled advertise=enabled

Pronto. Agora todos os dispositivos da sua rede doméstica terão endereços IPv6 reais da internet. Vá em outro computador e tente rodar o comando

ping ipv6.google.com

ou usando o seu celular via wi-fi na sua rede local navege para o site test-ipv6.com. Os celulares com Android já possuem suporte ao IPv6 via wi-fi.

Isso ocorre porque, apesar do seu Mac ter as duas coisas necessárias funcionando, o PHP está desativado no Apache (o que me faz questionar o sentido da vida). Reverter isso, porém, é muito simples, basta seguir esses poucos passos.

Editando o httpd.conf

O arquivo httpd.conf é o arquivo com as configurações do Apache, todos os tipos de serviço que ele roda e, “até” a configuração de ativar o PHP.

Abra o Terminal (pelo Spotligh ou similar, ou pelo caminho /Applications/Utilities/Terminal.app) e digite (você pode substituir o nano pelo seu editor preferido, como o TextMate) :

sudo nano /etc/apache2/httpd.conf

Com o arquivo aberto, procure pela seguinte linha (é a 111 se você nunca tocou nesse arquivo e está no Lion):

111

#LoadModule php5_module libexec/apache2/libphp5.so

Tudo que você precisa fazer agora é “descomentá-la”, removendo a cerquilha (#) e salvando o arquivo.

Reiniciando o Apache

Você pode iniciar/reiniciar o Apache indo nas Preferências e, em Compartilhamento, e ativando Compart. Web.

Se estiver ativado, desative e ative de novo!

Testando

Para ver se está tudo ok, crie o arquivo “index.php” e coloque-o na pasta Sites do seu usuário.

Neste arquivo, insira o seguinte texto:

1

<?php phpinfo() ?>

Agora, vá no seu navegador preferido e digite localhost/~nome_do_seu_usuario.

O resultado deve ser uma página gigante, com todas as informações da sua instalação PHP, similar à da imagem abaixo.

"Pouca" informação…

Fiz uma rápida pesquisa e acabei instalando dois para testar. Um deles achei decente, com configurações dentro do próprio painel dos Widgets, o outro, não pois as configurações ficavam em um outro lugar e ele criava um novo item no já gigante painel de administração do WordPress. Não bom!

Não preciso de mais um painel principal!

Decidi então ficar com o primeiro, já que ele me parecia mais dentro dos padrões de uso que estou acostumado.

Testando o Plugin de base

Configurei o Plugin, fui ver como estava ficando e encontrei o primeiro problema, o título. O comportamento padrão dos Widgets é não mostrar nada se você escolher não colocar um título. Não foi o caso desse Plugin. Ao não por um título, ele simplesmente veio em branco, mas a barra de título do tema estava lá, estragando tudo.

Pra completar, não conseguia trocar a cor da borda e, pra piorar, como a versão pequena do logo do Universo tem a forma de gota e o Facebook não curte PNG, o fundinho azul deixava o logo com aquela marca branca maldita!

Foi então que comecei a colocar a mão no código, apenas com o objetivo de corrigir esses probleminhas.

Deixando bonito

Depois de estudar um pouco o código original, percebi que ele estava usando uma API antiga do Facebook e que, com ela, eu não ia conseguir deixar do jeito que eu queria.

Barrinha maldita! Bordinha maldita! Fundinho azul maldito!

Comecei a cavocar e alterar o código, fiz um monte de POG pra ir vendo como ficava e acabei tendo o resultado que eu esperava, com bordinha arredondada, colado num dos cantos, fundo branco etc.

Isso sim é encaixe!

Aí, chegou o momento da verdade. O Diabinho gritando: “Tá ótimo, parte pra próxima!”. O Anjinho gritando: “Tá tosco, meu filho! Funciona, mas ninguém nunca mais vai conseguir arrumar isso de maneira fácil. Faz direito!”. Sim, o Anjinho é prolixo.

Transformando o POG em Plugin

Resolvi ouvir o Anjinho e percebi que a coisa era relativamente simples. Um Plugin de WP se resume a basicamente a formulário, Widget e registro junto ao WordPress.

O Widget já estava funcionando via POG, bastava transformar tudo que estava hard coded em utilização de parâmetros.

O registro do Plugin junto ao WordPress já tinha vindo junto do código original… não havia muito a ser feito.

O formulário é que deu um pouco mais de trabalho, já que resolvi que ia usar um outro componente (text area) que não existia no formulário orginal (nele, só tinha text box e check box).

Já que resolvi escrever um post sobre o assunto, vou comentar tudo que foi feito, com um pouquinho de código pra vocês… seus geeks! O código fonte completo pode ser baixado na própria página do Plugin “Styled Facebook Like Box”.

Metendo a mão no código

Parâmetros

A primeira coisa que comecei a alterar, já que a API nova do Facebook era um pouco diferente, foi a lista de parâmetros utilizados no form.

13
14
15
16
17
18
19
20
21
22

$styled_facebook_like_box_options['widget_fields']['title'] = array('label'=>'Widget title:', 'type'=>'text', 'default'=>'Facebook', 'class'=>'widefat', 'size'=>'', 'help'=>'The title before your widget');
$styled_facebook_like_box_options['widget_fields']['profile_url'] = array('label'=>'FanPage URL:', 'type'=>'text', 'default'=>'http://facebook.com/universo.mobi', 'class'=>'widefat', 'size'=>'', 'help'=>'Your Facebook Fan Page URL');
$styled_facebook_like_box_options['widget_fields']['width'] = array('label'=>'Width:', 'type'=>'text', 'default'=>'300', 'class'=>'', 'size'=>'3', 'help'=>'(Value in px)');
$styled_facebook_like_box_options['widget_fields']['height'] = array('label'=>'Height:', 'type'=>'text', 'default'=>'550', 'class'=>'', 'size'=>'3', 'help'=>'(Value in px)');
$styled_facebook_like_box_options['widget_fields']['border_color'] = array('label'=>'Border color:', 'type'=>'text', 'default'=>'#000', 'class'=>'', 'size'=>'', 'help'=>'(#E1E4E6, white)');
$styled_facebook_like_box_options['widget_fields']['background_color'] = array('label'=>'Background color:', 'type'=>'text', 'default'=>'#FFF', 'class'=>'', 'size'=>'', 'help'=>'(#E123F0, blue)');
$styled_facebook_like_box_options['widget_fields']['faces'] = array('label'=>'Show faces:', 'type'=>'checkbox', 'default'=>true, 'class'=>'', 'size'=>'', 'help'=>'Show profile photos');
$styled_facebook_like_box_options['widget_fields']['stream'] = array('label'=>'Show stream:', 'type'=>'checkbox', 'default'=>false, 'class'=>'', 'size'=>'', 'help'=>'Show profile stream');
$styled_facebook_like_box_options['widget_fields']['header'] = array('label'=>'Show header:', 'type'=>'checkbox', 'default'=>false, 'class'=>'', 'size'=>'', 'help'=>'Show default Facebook header');
$styled_facebook_like_box_options['widget_fields']['style_code'] = array('label'=>'Style code:', 'type'=>'textarea', 'default'=>'-moz-border-radius: 10px; border-radius: 10px; -webkit-border-radius:10px;', 'class'=>'', 'rows'=>'6', 'cols'=>'31', 'help'=>'margin-left: -40px; border-radius: 10px;');

Não sei se essa é uma forma normal de declarar os parâmetros de Widgets, mas achei bem interessante relativamente fácil de manejar. Tudo que tive que fazer foi alterar os arrays para os parâmetros que ia usar, acrescentar um novo tipo (textarea, na linha 22) e colocar uns helps decentes.

O Widget propriamente dito

O Widget propriamente dito foi o que realmente fez a diferença, já que antes eu não tinha controle de como o ele ficava na tela.

24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Output the widget in the sidebar
function styled_facebook_like_box($title, $profile_url, $width, $height, $faces, $border_color, $background_color, $stream, $header, $style_code){
	//Insert Facebook default JavaScript
 	echo "<div id='fb-root'></div>
		<script>(function(d, s, id) {
 		var js, fjs = d.getElementsByTagName(s)[0];
 		if (d.getElementById(id)) return;
 		js = d.createElement(s); js.id = id;
 		js.src = '//connect.facebook.net/pt_BR/all.js#xfbml=1';
		fjs.parentNode.insertBefore(js, fjs);
		}(document, 'script', 'facebook-jssdk'));</script>";
	//Insert the styled Like Box
	echo "<div class='fb-like-box' data-href='$profile_url' data-width='$width' data-height='$height' data-show-faces='$faces' data-border-color='$border_color' data-stream='$stream' data-header='$header' style='background-color:$background_color;";
	if ($style_code)
		echo $style_code;
	echo "'></div>";
}

Dessa forma, na linha 27 eu joguei o JavaScript da página de desenvolvimento do Facebook (que eles recomendam que eu jogue no início do Body do HTML, mas eu não tinha ideia de como fazer isso via plugin) e na linha 37 a DIV que será preenchida pelo Facebook.

Repare que na linha 38 eu coloco um campo como opcional, que é exatamente a textarea do formulário. So nada for colocado nela, esse trecho é desconsiderado.

O código do  Plugin tem uma funçãozona com outras dentro. Entre elas, a do formulário e a que chama essa função (styled_facebook_like_box) que mostrei acima.

Aqui, segue o início dela:

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

function widget_styled_facebook_like_box_init(){
	if (!function_exists('register_sidebar_widget'))
		return;
	$check_options = get_option('widget_styled_facebook_like_box');
 
	// Show the Widget in the sidebar
	function widget_styled_facebook_like_box($args){
 
		global $styled_facebook_like_box_options;
		extract($args);
		$options = get_option('widget_styled_facebook_like_box');
 
		// Fill options with default values if value is not set
		$item = $options;
		foreach($styled_facebook_like_box_options['widget_fields'] as $key => $field){
			if (! isset($item[$key])){
				$item[$key] = $field['default'];
			}
		} 
 
		$title = $item['title'];
		$profile_url = $item['profile_url'];
		$width = $item['width'];
		$height = $item['height'];
		$faces = $item['faces'] ? "true" : "false";
		$border_color = $item['border_color'];
		$background_color = $item['background_color'];
		$stream = ($item['stream']) ? "true" : "false";
		$header = ($item['header']) ? "true" : "false";
		$style_code = $item['style_code'];
 
		//Remove the Wordpress Title if none was set
		if ($title)
			echo $before_widget . $before_title . $title;
 
		echo $after_title; 
 
 	styled_facebook_like_box($title, $profile_url, $width, $height, $faces, $border_color, $background_color, $stream, $header, $style_code);
 	echo $after_widget;
	}

A função widget_styled_facebook_like_box pega todos os parâmetros preenchidos no formulário e, com eles, chama a styled_facebook_like_box. Tudo que fiz aqui foi alterar os parâmetros que eram usados.

O formulário

Esse foi o pedaço que mais deu trabalho, exatamente porque tive a brilhante ideia de usar a textarea. Diferente de tudo que já era usado no formulário que funciona como “<input type=’algum tipo…”, a text area tem uma tag que abre com ela mesma e não com um tipo, assim “<textarea…>alguma coisa</textarea>. Então sofri um pouco para conseguir colocá-la na tela.

Achei a maneira de colocar criar o formulário do código que usei de base muito elegante, já que fazia tudo dentro de um loop, em vez de fazer na unha, então resolvi manter, apesar da dificuldade maior.

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

	// Output the widget form
	function widget_styled_facebook_like_box_control(){
 
		global $styled_facebook_like_box_options;
 
		$options = get_option('widget_styled_facebook_like_box');
		if (isset($_POST['styled_facebook_like_box-submit'])){
 
			foreach($styled_facebook_like_box_options['widget_fields'] as $key => $field){
				$options[$key] = $field['default'];
				$field_name = sprintf('%s', $key);
				if ($field['type'] == 'text' || $field['type'] == 'textarea'){
					$options[$key] = strip_tags(stripslashes($_POST[$field_name]));
				}
				elseif ($field['type'] == 'checkbox'){
					$options[$key] = isset($_POST[$field_name]);
				}
			}
 
			update_option('widget_styled_facebook_like_box', $options);
		}
 
		foreach($styled_facebook_like_box_options['widget_fields'] as $key => $field){
			// print_r($field);
			$field_name = sprintf('%s', $key);
			$field_checked = '';
			if ($field['type'] == 'text' || $field['type'] == 'textarea'){
				$field_value = (isset($options[$key])) ? htmlspecialchars($options[$key], ENT_QUOTES) : htmlspecialchars($field['default'], ENT_QUOTES);
			} elseif ($field['type'] == 'checkbox'){
				$field_value = (isset($options[$key])) ? $options[$key] :$field['default'];
				if ($field_value == 1){
					$field_checked = 'checked="checked"';
				}
			}
			$jump = ($field['type'] != 'checkbox') ? '<br />' : ' ';
			$field_class = $field['class'];
			$field_size = ($field['class'] != '') ? '' : 'size="'.$field['size'].'"';
			$field_help = ($field['help'] == '') ? '' : '<small>'.$field['help'].'</small>';
			//Exclusive for textarea
			$field_rows = ($field['rows'] == '') ? '' : 'rows="'.$field['rows'].'"';
			$field_cols = ($field['cols'] == '') ? '' : 'cols="'.$field['cols'].'"';
			if ($field['type'] != 'textarea'){
				printf("<p class='styled_facebook_like_box_field'>".
						"<label for='$field_name'>" . __($field['label']) . "</label>$jump".
						"<input id='$field_name' name='$field_name' type='" . $field['type'] . "' value='$field_value' class='$field_class' $field_size $field_checked />".
						"$field_help</p>");
			}
			else{
				printf("<p class='styled_facebook_like_box_field'>".
						"<label for='$field_name'>" . __($field['label']) . "</label>$jump".
						"<textarea id='$field_name' name='$field_name' value='$field_value' class='$field_class' $field_rows $field_cols>$field_value</textarea>".
						"$field_help</p>");
			}
		}
		echo '<input type="hidden" id="styled_facebook_like_box-submit" name="styled_facebook_like_box-submit" value="1" />';
	}

Basicamente, tive que acrescentar as linhas 122, 123 e 124, já que são parâmetros de linhas e colunas exclusivos de um textarea (foram definidos lá no começo, na linha 22) e o trecho que inicia na linha 131.

Com isso, o form do widget ficou assim:

Form final do "Styled Facebook Like Box"

Ficou exatamente como eu queria, com os campos padrão do Widget do Facebook, mas a textarea com um campo para colocar formatações CSS.

Registrando junto ao WP

Finalmente, entra o código para registrar o Plugin junto ao WordPress. Esse código é o que permite que o Plugin seja reconhecido como um Widget.

141
142
143
144
145
146
147
148
149

	// Register the widget with WordPress
	function widget_styled_facebook_like_box_register(){
		$title = 'Styled Facebook Like Box';
		// Register widget for use
		register_sidebar_widget($title, 'widget_styled_facebook_like_box');
		// Register settings for use, 300x100 pixel form
		register_widget_control($title, 'widget_styled_facebook_like_box_control');
	}
	widget_styled_facebook_like_box_register();

As únicas coisas alteradas aqui forams o nome do Plugin e os nomes das funções chamadas.

Mandando tudo para o wordpress.org

Depois de ter feito tudo isso e testado bastante, resolvi que esse plugin merecia mais do que ficar preso ao blog do Universo. Dei uma pesquisada e vi que era muito fácil submetê-lo à lista de Plugins do WordPress.

Basta entrar no site do WordPress (o .org, não o .com) criar um cadastro, preencher o formulário de submissão e fazer upload de um .zip com seu plugin. Seu plugin deve ter alguns comentários que o descrevem, um TXT e ainda é possível colocar screenshots. Isso tudo é usado para a página do seu Plugin e esse texto é apresentado quando seu Plugin é instalado no WordPress.

Após algumas horas, recebi um email dizendo que o Plugin tinha sido aprovado e que eu já podia enviá-lo por SVN.

Subi os arquivos e, quase que instantaneamente, lá ele estava. Depois de algum tempo de teste, resolvi corrigir algumas coisas, mudei a versão e subi novamente. O processo de atualização foi totalmente automático e não tive que fazer nada pra que ele mudasse da 1.0 para 1.1 e depois para a 1.2.

Finalmentes

Acei todo o processo bastante simples, desde o desenvolvimento (Ok, usei um outro plugin como base, mas, mesmo assim, não é nada de outro mundo)até a submissão.

Foi divertido e empolgante ver o plugin no ar (em 1 dia, já teve 288 instalações) e sendo usado! Me empolguei tanto, que instalei aqui no Bit a Bit!

Um dos motivos que me fez demorar de abandonar o FireFox era um pluginzinho (FaviconizeTab) que dava um “pin” em abas que eu determinava conforme uma Expressão Regular de URL. Dessa forma, deixava as coisas que acesso o dia todo fixas num canto, ocupando menos espaço que uma aba normal.

Procurei muito por isso no Chrome e, enfim, achei!!!

A extensão se chama URL Pinner e funciona praticamente da mesma forma que minha velha conhecida. Basta escolher qual RegEx você quer “Auto Pinar”, salvar e pronto!

Configurações do URL Pinner

Feito isso, basta acessar as URLs especificadas, que elas vão para o cantinho delas! Você pode até dizer a ordem que quer que elas fiquem (não tinha isso no que eu usava no FF) e elas se arranjam!

URL Pinner em ação

As teclas de atalho não funcionaram no Mac, mas, como o que mais me importava era realmente a função de automatizar o processo, nem me importei!