Archive

Archive for the ‘Informática’ Category

Como computadores enlouquecem (AI)

January 15th, 2012 No comments

[Publicação de brainstorm, não texto argumentativo]

Ontem entendi por acidente porque o sujeito “enlouquece” numa solitária (enquanto pensava sobre inteligência artificial).

Partindo de onde achei a coisa… O que aconteceria com dois AI-bots conversando entre si se o pensamento deles tivesse funcionamento semelhante ao nosso e eles não tivessem mais acesso a dados do mundo real?

Antes, deixe-me expor um ponto. O pensamento é criativo… Se você puser um macaco com fome num ambiente com uma banana suspensa e uma cadeira disposta perto, ele fatalmente vai usar a cadeira para alcançar a banana. Apesar de ser uma ideia muito simples, o poder computacional necessário para se fazer a mesma coisa seria enorme… [A não ser obviamente que fosse um programa específico para alcançar objetos em lugares altos usando-se elementos disponíveis no chão, né? Digo um meta-algoritmo geral]. Não há qualquer ligação entre o significado de banana e o de cadeira que pudesse ser aproveitada num raciocínio analítico (fora alguma galhofa que você quiser pensar) para que o resultado fosse calculado de modo simples. É um flagrante do pensamento que extrapola a experiência. [Tenho suspeitas de como isso se dá, mas seria material de outro post. Deixemos amadurecer mais...].

A questão é: se o pensamento tem um algoritmo criativo [vai além da mera compreensão dos objetos ao redor] podendo inclusive simular ambientes físicos e verificar a viabilidade de se executar uma ação num ambiente imaginário, como impedir que o pensamento continue criando independentemente da realidade levando o sujeito/bot à explosão arbitrária de raciocínios triviais? Noutras palavras, como calcular a economia do raciocínio?

Minha conclusão temporária é que a mente sempre raciocina e cria – com ou sem dados da realidade. Se alguém é privado da rica experiência da realidade, com o tempo, ela, na falta de dados exteriores, procura otimizar os dados que já tem. Mas isso tem um risco, pois se o sujeito tem uma visão equivocada sobre o mundo real essa idéia vai se tornar mais forte em cativeiro. Ou mesmo uma ideia verdadeira, mas de importância menor pode ganhar peso desproporcional quando o sujeito se expõe somente a ela.

Numa solitária, não há bastante dados sobre o mundo. Assim, a mente continua funcionando e criando sem eles levando o sujeito à loucura (temporária ou não) já que a mente começa a criar a partir apenas do vazio e do que já tem. Ocorre, então, um círculo vicioso do pensamento que degenera a mente quanto às suas funções normais.

Ah, sobre os AI-bots, creio que aconteceria o mesmo: enlouqueceriam – se eles não houverem sido melhor desenhados do que fomos nós pelo acaso.

Categories: Filosofia, Informática, Outros, Psicologia Tags:

JavaScript “read-only” Object

September 22nd, 2011 No comments

This is yet the best hack I found…

function A () { // context container

	var privateA = 'XYZ';

	function B () {

		var privateB = 'xyz';

		this.v1 = 1;
		this.v2 = 'b';
		this.f1 = function () { return privateA; };
		this.f2 = function () { return privateB; };
	}

	var newB = new B();

	for (i in newB) arguments.callee[i] = newB[i]; // copy B methods to A

	return arguments.callee;
};
A(); // initialize

A.v1;   //=> 1
A.v2;   //=> "b"
A.f1(); //=> "XYZ"
A.f2(); //=> "xyz"

A.v1;     //=> 1
A.prototype.v1 = 2; // no effect
A.v1;     //=> 1
A.v1 = 2; // A.v1 changed...
A.v1;     //=> 2
A();      // regenerate...
A.v1;     //=> 1 // original content

A.v3 = 'whatever';
A();
A.v3 //=> "whatever"

A.f1(); //=> "XYZ"
A.f1 = function () { return 'Oh, no! The public function is lost...' };
A.f1(); //=> "Oh, no! The public function is lost..."
A();    // come on, baby
A.f1(); //=> "XYZ" // :-) 

Have fun

Categories: Informática Tags:

Go no GCC (golang.org)

March 29th, 2011 No comments

É isso mesmo! A linguagem Go foi incluída no GCC 4.6 (GNU Compiler Collection). Isso significa que subiu oficialmente ao hall das importantes linguagens mundiais, principalmente das open-source. Assim, virá na coleção padrão de compiladores do Linux e outros sistemas assim como já vinham C, C++, Objective-C, Java etc.

Eu esperava por isso já faz algum tempo, pois  creio ser bem merecido. Go é uma linguagem maravilhosa e tem tudo para – sem exagero – substituir com folga as grandes linguagens que temos no mercado! Eu sei que cada qual defende sua linguagem com unhas e dentes, mas se você considerar ponderadamente o que Go é, acho difícil que duvide do meu prognóstico.

Principais características:

  • É compilada para código de máquina (não bytecode) e de tipagem estática (validada em tempo de compilação), portanto sua velocidade é comparável à de C e a tendência é se tornar cada vez mais rápida por otimização em futuras releases.
  • É simples de aprender. A sintaxe é semelhante à de C de algum modo, mas muito mais afinizada com linguagens dinâmicas contemporâneas como Python.
  • Suporta orientação a objeto. Mas com características peculiares muito interessantes… Objetos sem classes. São tipos/estruturas com seus métodos (funções vinculadas a eles), interfaces e packages [veja mais a seguir].
  • É robusta e franca
    • Suporta processos concorrentes como recuso built-in.
    • Suas facilidades não iludem o programador sobre o que está ocorrendo nos bastidores.
    • É desenhada para aceitar caracteres UTF-8 por default inclusive em identificadores de variáveis e funções!
    • Tem recurso de inferência concisa de tipos para declaração simplificadas.
    • Tem “coletor de lixo” (garbage collector).
    • Explora o poder de processadores multicore.
    • Tem muuuitas bibliotecas padrão com tudo o que você geralmente sente que precisa e falta em outras linguagens.
    • O código é tão legível que já é quase sua própria documentação e é fácil tanto para programadores quanto para o compilador rastrear as dependências pelas regras de importação.
    • O compilador avisa sobre variáveis ou packages declaradas mas não utilizadas.
    • Possui biblioteca para números arbitrariamente grandes ou arbitrariamente precisos.
  • É segura quanto ao tipo e quanto ao acesso à memória (tem ponteiros mas não ponteiros aritméticos e o tamanho de uma array é parte do tipo da array).
  • É limpa. Graças ao bom Deus não me puseram shorthands como “templates” para declaração de múltiplos tipos o que arruinaria aquele monumento ao rigor que Go é. Mas alguns conceitos sobre manipulação de tipo ainda estão em discussão, porém cada vez menos se sente a necessidade de novos recursos para tal.
  • É uma linguagem de sistema (pode ser usada para desenvolver sistemas operacionais), mas é ao mesmo tempo de uso geral.
  • É modesta. [Isso eu demorei um pouco para valorizar, mas vendo a coisa na prática tenho que julgar que foi um acerto, dadas as circuntâncias]. Ou seja, não tenta vencer conceitualmente linguagens intelectuais como Scheme e tantas outras interessantes, mas simplesmente dá o que precisamos sem paradigmas desnecessariamente sofisticados que poderiam tornar o ato de programar muito burocrático. Em suma, tem sua rigorosa filosofia, mas evita “filosofices” puramente acadêmicas e anti-pragmáticas ou até mesmo boas idéias que não caberiam nesse momento histórico.
  • É open source (você por ir lá na lista de email e influenciar a linguagem), bem como usar à vontade.
  • É patrocinada e fomentada pelo Google, feita principalmente pelo time do Google que inclui grandes nomes da história da informática e novas mentes brilhantes. Esse fator é relevante porque muitas vezes uma linguagem é maravilhosa mas “não pega” amplamente como no caso de D. Com um fomentador de porte e qualidade, não há como “não pegar”.
  • É madura. Aprendeu com os erros e acertos de grandes linguagens e veio numa época em que conceitos de linguagens de programação foram testados e regenerados à exaustão. Portanto, pôde contar com um desenho firme, elegante e seguro.

Isso é apenas uma amostra, portanto espero que não julgue a linguagem somente pelo meu post. A seguir, ponho alguns exemplos relevantes, mas dê uma olhada no site oficial. E você pode testar a linguagem online.

Exemplos

Programa mínimo

package main

func main() {
    //code
}

Hello world

package main

import "fmt"

func main() {
    fmt.Println("Olá Mundo!")
}

Inferência de tipo

package main

import "fmt"

func main() {

    var s1 string // tipo declarado
    s1 = "Olá "

    s2 := "Mundo" // tipo inferido

    fmt.Println(s1 + s2)
}

Caracteres UTF-8 por padrão, inclusive em identificadores

package main

import "fmt"

func main() {
    Saudação()
}

func Saudação() {
    fmt.Println("Olá Mundo!")
}

Processos concorrentes (exemplo trivial)

package main

import (
    "fmt"
    "time"
)

func main() {

    sec := int64(1000000000) // 1 segundo em nanosegundos

    // "go" aciona o processo e continua sem esperar
    go DigaNoTempo("Mundo!", 3 * sec)
    go DigaNoTempo(" ",      2 * sec)
    go DigaNoTempo("Olá",    1 * sec)

    time.Sleep(4 * sec) // aguardando os processos...
    fmt.Printf("\n")
}

func DigaNoTempo(s string, t int64) {
    time.Sleep(t)
    fmt.Printf(s)
}

// output: Olá Mundo!

Funções anônimas

package main

import (
    "fmt"
)

func main() {

    f := (func() func() {
        n := 0
        return func () {
            n = n + 1
            fmt.Printf("%d ", n)
        }
    })()
    // função anônima (executada) que retorna função anônima como em JavaScript

    f()
    f()
    f()
    fmt.Printf("\n")
}

// output: 1 2 3

Orientação a objeto (tipo numérico)

package main

import (
    "fmt"
)

func main() {

    n := new(Natural)
    *n = 4

    if n.ÉZero() {
        fmt.Printf("%v é zero\n", *n)
    } else {
        fmt.Printf("%v não é zero\n", *n)
    }

    if n.ÉPar() {
        fmt.Printf("%v é par\n", *n)
    } else {
        fmt.Printf("%v não é par\n", *n)
    }
}

type Natural uint // uint é o inteiro sem sinal de 16 bits

func (n *Natural) ÉZero() bool {
    if *n == 0 {
        return true
    }
    return false
}

func (n *Natural) ÉPar() bool {
    if n.ÉZero() || *n%2 == 0 {
        return true
    }
    return false
}

/* output:
4 não é zero
4 é par
*/
Categories: Informática Tags:

Model Rails 3 serializado (sem ActiveRecord)

October 24th, 2010 No comments

Às vezes você quer carregar informações configuráveis em seu aplicativo Rails que não estão num banco de dados. Geralmente a alternativa é colocar num documento passível de serialização e carregar por initializer (config/initializers/*.rb). O problema é que o seu cliente não vai editar esse arquivo no servidor via vim/ssh ou baixando via ftp ou de alguma maneira parecida, então o ideal seria que esses dados se comportassem como um model ActiveRecord podendo ser editado via formulário normal.

Para dar um exemplo prático… Há informações de um site que não faz sentido que estejam numa tabela, porque seria como que uma tabela de uma linha só. Digamos… Título, slogan, descrição, status (no ar ou em manutenção) etc.

Eis o passo-a-passo da maneira mais simples que encontrei…

No Shell:

rails new app
cd app
rails g scaffold Conf title:string slogan:string desc:text
rm db/migrate/*_create_confs.rb
rm -rf app/views/confs/*
touch app/models/conf.yml

Arquivos:

# app/helpers/application_helper.rb
module ApplicationHelper
  def app_conf
    unless defined?(@app_conf)
      @app_conf = YAML.load(File.read("#{Rails.root}/app/models/conf.yml")).symbolize_keys
    end
    @app_conf
  end
end

# config/routes.rb
App::Application.routes.draw do
  get "confs/", :controller => :confs, :action => :edit
  post "confs/set", :controller => :confs, :action => :update
end

# app/controllers/confs_controller.rb
class ConfsController < ApplicationController

  def edit
    @conf = Conf.new
  end

  def update
    @conf = Conf.new(params[:conf])
    if @conf.save
      flash[:notice] = "Successfully updated configuration."
      redirect_to confs_path
    else
      render :action => 'edit'
    end
  end

end

# app/models/conf.rb
require 'active_model'
require 'yaml'

class Conf
  include ActiveModel::Conversion
  include ActiveModel::Validations
  extend ActiveModel::Naming

  attr_accessor :title, :desc, :slogan

  def initialize(attributes = {})
    @_conf_path = "#{Rails.root}/app/models/conf.yml"
    @_data = attributes
    begin
      @_data = YAML.load(File.read(@_conf_path)) if @_data.empty?
    rescue
      @_data ||= {}
    end
    if @_data.class == Hash
      @_data.each do |name, value|
        send("#{name}=", value)
      end
    end
  end

  def save
    File.open(@_conf_path, 'w') {|f| f.write(@_data.to_hash.to_yaml) }
    true
  end

  def persisted?
    false
  end

end

# app/views/confs/edit.html.erb
<h1>Editing config</h1>

<%= form_for @conf, :url => confs_set_path do |f| %>
  <% if @conf.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(@conf.errors.count, "error") %> prohibited this conf from being saved:</h2>

      <ul>
      <% @conf.errors.full_messages.each do |msg| %>
        <li><%= msg %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= f.label :title %><br />
    <%= f.text_field :title %>
  </div>
  <div class="field">
    <%= f.label :slogan %><br />
    <%= f.text_field :slogan %>
  </div>
  <div class="field">
    <%= f.label :desc %><br />
    <%= f.text_area :desc, :size => '40x5' %>
  </div>
  <div class="actions">
    <%= f.submit 'Change config' %>
  </div>
<% end %>

# app/views/layouts/application.html.erb
<!DOCTYPE html>
<html>
<head>
  <title><%= app_conf[:title] %><%= app_conf[:slogan].empty? ? '' : (' - '+ app_conf[:slogan])  %></title>
  <%= stylesheet_link_tag :all %>
  <%= javascript_include_tag :defaults %>
  <%= csrf_meta_tag %>
</head>
<body>
<% flash.each do |name, msg| %>
<%= content_tag :div, msg, :id => "flash_#{name}" %>
<% end %>
<%= yield %>

</body>
</html>

Assim os dados são carregados normalmente no formulário para que você os edite. Como esses dados não são para ser usados numa só página, mas por toda a aplicação, não há necessidade de uma action show. Essa página de edição deve, obviamente, ser assegurada por regras que administração que não estão nesse post só para não ficar confuso.

Outra vantagem dessa abordagem é que os dados são atualizados em tempo real. Se fossem carregados num initializer, seria preciso reiniciar a aplicação para que fossem atualizados.

Categories: Informática Tags:

Kindle

September 23rd, 2010 5 comments

Posso dizer que o Kindle (geração 3) superou minhas expectativas. E isso significa alguma coisa, já que eu sou muito chato.

Eu queria uma solução barata para ler e-books que não sentado no computador ou com laptop (é, eu não comprei para postar sobre ele, na verdade @pedromenezes sugeriu que postasse) e que permitisse ler os livros que o Papai Noel oferece para dar uma olhada antes de comprar (meu advogado me pediu para dizer isso :-) .

A proposta do Kindle é minimalista. Ele faz uma só coisa e a faz muito bem: permitir ler e-books. Pelas características da coisa, dá para ver que é fruto de um projeto bem pensado. Acho que chamaram um bando de leitores religiosos de livro impresso e perguntaram: o que impede vcs de ler num aparelho eletrônico? E disseram:

  • Quero poder ler no Sol sem o brilho da tela incomodando
  • Quero poder fazer comentários no livro e grifá-lo
  • Quero algo portátil como um pocket book
  • Quero não ter de me preocupar com bateria
  • Um leitor digital tem de oferecer mais do que o que um livro comum oferece…

E a Amazon disse: faça-se o Kindle! E o Kindle se fez. E vi, eu, que o Kindle era bom…

Deixe-me esclarecer um equívoco que anda rondando a Internet: iPad e Kindle são coisas diferentes; não competem entre si. Quando você tiver um Kindle nas mãos vai entender o que estou dizendo. A tela do Kindle não é como a de um monitor, não tem luminosidade nem reflexo, parece uma folha impressa. Engraçado que ele vem com as instruções na tela e eu bem achei que fosse uma folha colada sobre a tela e fiquei tentando tirar, acredita? Sério… é esse o nível de definição. Por enquanto não senti falta das cores… o preto-e-branco dá um contraste muito bom, fica uma coisa retrô bacana. Já o iPad é um computador mesmo: faz um monte de coisas, pesa, a tela reflete, a bateria não faz milagres. Ou seja, é excelente enquanto computador (eu quero um, aliás), mas não substitui o Kindle como leitor de livros digital, opinião minha.

Vamos fazer um pequeno inventário das…

Características mais notáveis:

  • Como dito, a tela é foda, parece ter um sistema semelhante ao do “MagicBoard”. Isso é uma grande sacada porque não fica gastando energia para manter a tela impressa, só quando vai mudar de página ou animar alguma coisa (viu porque às vezes é melhor fazer só uma coisa, mas bem feita?).
  • Tem o tamanho certo (estou falando do pequeno, não testei o DX), grande o bastante para não fazer da leitura um desafio, pequeno o bastante para caber no bolso de um casaco e é bem leve.
  • Tem botões específicos para a leitura como o de ir para a próxima página ou para a anterior de ambos os lados (vc só precisa de uma mão, sendo destro ou canhoto). Também um pequeno teclado com o qual você pode fazer comentários no texto (e tem a opção de publicá-los para os outros leitores!) e com botões: Menu, Home, Back e Aa com o qual você altera tamanho de fonte, orientação de tela etc.
  • Aceita os formatos: AZM (proprietário, MOBI alterado), MOBI, EPUB, TXT e converte outros formatos (como PDF, Word) automaticamente para arquivos equivalentes legíveis.
  • Seu Kindle fica vinculado à sua conta na Amazon. Assim, você pode comprar um livro via Internet pelo próprio Kindle (wireless ou 3g) e não precisa comprar mais de uma ver o mesmo livro ao trocar de Kindle. Também é possível publicar um livro seu no mesmo site e vendê-lo como autor amador ou profissional.
  • Você ganha um e-mail Kindle tal que ao enviá-lo e-mail com aquivo anexo como Word (.doc), PDF, HTML zipado etc ele envia para o seu Kindle com a opção de fazê-lo já convertido para formato AZM se você por ‘convert’ no título do e-mail.
  • Você pode criar coleções de livros para não ficar aquela zona (eu gostaria que se pudesse por uma coleção dentro de outra tb, mas não). E pode procurá-los por filtros como: autor, título, mais recentes e por coleção, claro.
  • A bateria dura pacas Do tipo eu estar ouvindo audio-books há alguns dias desde que comprei e ainda não ter gastado a metade. Imagina apenas lendo e-books. Dizem que ligado direto ele dura umas 3 semanas. Desligado, meses.
  • Text-to-speech, ele lê um documento de texto para você (eu nem tentei em português…). Não rola com PDF, tem que converter.
  • Tem como recursos experimentais leitor de mp3 e um navegador (um decente webkit) mas, como não é feito para isso não tem cores e sem muitas animações (sem gif animado nem flash, claro). Mas pode ser o bastante para você baixar aquele livrinho… (MOBI, AMZ, TXT e alguns outros… parece haver uma certa resistência proposital a alguns formatos como o PDF; eles não estão de bobeira né…).
  • Quando você desliga o Kindle, ele deixa na tela uma imagem randômica de muito bom gosto, seja a pintura de um autor famoso, ou uma imagem retrô.
  • Custa $139.00 (dólares) =  muito barato. Acho que a Amazon está vendo como meio, não como produto final.

Kindle: um motivo a menos para ter vida social eheh.

Considerações…

  • O Kindle DX parece perder o benefício de ser portável e é caro… Nesse caso pode valer a pena ir pro iPad (viu como não é um post patrocinado? eheh).
  • O recurso do 3g (internet via protocolo de celular) é pago pelo acesso. Eu to fora, uso wireless só.
  • Eu não mandaria um arquivo pirata para o email do Kindle para ser convertido para ebook e enviado para seu Kindle se fosse vc. Podem não estar se preocupando com isso agora, mas o futuro nem Deus sabe… Ah, eu mencionei que vem com cabo USB? Não tem nada a ver uma coisa com a outra é que eu lembrei agora e botei aqui mesmo.
  • O navegador e a possibilidade de baixar PDF e outros tipos de arquivo relevantes promete ser uma novela daquelas… Estaremos acompanhando.
  • Não rola ebook local em HTML (até onde tentei), mas na Web sim inclusive com JavaScript pesado. Mas ele interpreta tags HTML em documentos TXT, o que é meio bizarro… mas sem JavaScript.
  • Os juízes brasileiros liberaram em princíprio o imposto do Kindle (por se tratar de um produto exclusivamente para ler livros) para quem ou trouxer em viagem. Mas por aguma razão obscura comprar dietamente no site acarreta na combrança do imposto. Há rumores de que isso está em vias de se regularizar, mas eu não quis ficar esperando pela nossa ágil justiça brasileira. Como o serviço de entrega que escolhi foi o DHL, a Amazon cobra o dobro e devolve o restante depois que passar na alfândega. Nesse caso o valor ficou para mim $312.15 (dólares), R$546 (reais), meio salgadinho, mas depois se devolverá se Deus ou o pessoal da alfândega quiser, uma parte da metade disso. Demorou-se 4 dias úteis para chegar após ser enviado.

Críticas…

  • A navegação é boa, mas não tão fluente como a de um celular, digamos. Às vezes vc tem que apertar seguidas vezes as setas (contando que o refresh da tela é rápido mas não instantâneo) e isso incomoda um pouco um carinha frenético que nem eu.
  • Já que há suporte para audio-books, senti falta de botões de Play, Pause, etc em vez de virtualizados na tela (eu colocaria na parte na lateral direita superior para poder ser apertado com a capinha [compra opcional, mas padrão] fechada). Acredito que deva vir na geração 4.
  • Sinto falta também de um editor de texto simples…
  • Também seria legal, mas isso é da ordem da utopia… que você pudesse compartilhar arquivos com outros Kindles (ou computadores) via rede wireless, como uma pasta compartilhada. Mas há uma razão monetária para isso não acontecer… Mas também sabemos como a democracia hacker pode fazer tudo acontecer… rs

Para mim está valendo muito a pena. O conceito que me vem à mente com relação ao Kindle é o fim da ilusão da ferramenta universal… Você tem um órgão no corpo para cada coisa, não é? Imagina você respirar e digerir os alimentos pelo mesmo órgão… Vamos aprender com a mãe natureza e fazer ferramentas distintas para finalidades distintas. Assim cada uma funciona bem para aquilo a que é destinada em vez de ter uma coisa que faz tudo mais ou menos.

Nem sempre um bom projeto dá certo. Se não fosse um produto da Amazon, não ia rolar. Tem coisas que tem que ter alguém grande distribuíndo para dar o start no mercado e nesse caso felizmente há. Com relação à maturidade de projetos acho o número 3 muito bom. A terceira versão geralmente traz a melhor curva de desenvolvimento, é quando a coisa toma forma, e isso aconteceu com o Kindle.

Aconselho, portanto, testar essa ferramenta, pois parece valer a pena. Fico feliz de saber que uma enorme biblioteca pode ocupar agora o espaço de um livro e que isso é ecologicamente interessante sem ser um “porre” politicamente correto.

Espero que num futuro não muito distante algo semelhante faça parte definitiva do estudo acadêmico.

Boa leitura!

Categories: Informática Tags:

Multiplicação fácil em binário

August 18th, 2010 No comments

Um algoritmo é uma sequência de passos (incluindo decisões) para se alcançar um objetivo. Geralmente, o termo é usado para se referir a processos computacionais, mas não está restrito ao tema. Um mesmo problema pode ser resolvido por diversos algoritmos e depende dos recursos disponíveis qual será o mais eficiente naquele caso.

Um mesmo algoritmo pode ser eficiente para computadores, mas ineficiente para humanos e vice-versa. Humanos trabalham melhor com manipulação de imagens do que com processos abstratos (por isso muitas vezes os representamos em diagramas). Particularmente, me interesso por ambos. Entender o porquê de algoritmos serem mais humanos ou mais “máquina”  é um ótimo pretexto para aprender mais sobre os dois.

Aqui vai um exemplo de algoritmo humano para resolver multiplicações em binário de forma mais simples:

  1. Disponha os multiplicandos numa tabela de eixos ortogonais a 45º e 135º como na figura.
  2. Para facilitar use pontos para os zeros e traços para os uns e preencha o cabeçalho na ordem numérica normal.
  3. Onde os traços “se encontram”, marque traços verticais, no restante pontos.
  4. Some as linhas verticais como faria normalmente em binário (incluindo o “vai um”).
  5. O resultado estará na ordem numérica correta.

É o mesmo que faríamos numa multiplicação normal, mas de forma visualmente mais simples e significativa. É possível fazer o mesmo com decimais, mas assinalando os valores todos.

O presente post foi inspirado nesse vídeo.

(Esse método aqui eu não consegui entender, mas tb parece interessante).

Que a nerdice esteja com você.

ATUALIZAÇÃO

Para fazer a adição isolada ou como parte da multiplicação já citada, há outro algoritmo mais próximo do que normalmente usamos para somar:

  1. Preocupe-se apenas com o “vai um”, envolva de dois em dois os “uns” substituindo-os por 1 na próxima casa [em verde na imagem] (só que na parte de baixo para se poder acoplar na multiplicação).
  2. Você também pode, para facilitar, envolver de 4 em quatro quando houver tantos, e substituí-los por 1 duas casas adiante [em azul na imagem]. Se pode fazer o mesmo com 8, 16, 32… respectivamente 3, 4, 5 casas adiante [2n].
  3. Quando terminar, transcreva apenas os uns para baixo completando o restante com zeros (aqui não há mágica, a única diferença é circular os grupos para tornar o algoritmo mais visual).
Categories: Filosofia, Informática, Psicologia Tags:

Quine em Go

August 8th, 2010 No comments

Um programa Quine é aquele que gera como output exatamente seu próprio código fonte. Aí vai o meu feito em Go (golang.org).

[English: A Quine is a program that generates exactly it's own source code as output. That's one I made in Go (golang.org).]

/* quine.go by Daniel Mazza */

package main
import "fmt"

func main() {
s := `/* quine.go by Daniel Mazza */

package main
import "fmt"

func main() {
s := %s
fmt.Printf(s + "\n", string(96) + s + string(96))
}
`
fmt.Printf(s + "\n", string(96) + s + string(96))
}

Categories: Filosofia, Informática Tags:

Go Bitwise

July 10th, 2010 No comments

Operadores bitwise são os que atuam bit-a-bit. Em Go são:

  • & (AND)
  • | (OR)
  • ^ (NOT precedendo um operando e XOR entre dois)
  • &^ (AND-NOT, e-não, não-implicação)

Assim, por exemplo, 3|5 retornará 7, pois em binário 3 é 0011 e 5 é 0101 e | retorna 1 se qualquer um dos bits for 1, assim o resultado será 0111, que é 7 em decimal. Com esses operadores lógicos podemos alcançar todos os demais possíveis (quatro com um operando e dezesseis com dois operandos). Veja o código a seguir:

// Bitwise fun by Daniel Mazza
package main

import "fmt"

var (
	p uint8 = 3 // 0011
	q uint8 = 5 // 0101
)

func main() {

	// All possible binary logic operations (equivalent).
	// (Some parentheses are only to enhance readability)

	B1(
		(q &^ q), // 0  00 Contradiction
		(q),      // 1  01 Proposition Q
		(^q),     // 2  10 Negation of Q
		(q | ^q), // 3  11 Tautology
	)
	fmt.Println()
	B2(
		(p &^ p & q),   // 0  0000 Contradiction
		(p & q),        // 1  0001 Conjunction (AND)
		(p &^ q),       // 2  0010 Material nonimplication (AND-NOT)
		(p | (q &^ q)), // 3  0011 Proposition P
		(^p & q),       // 4  0100 Converse nonimplication
		((p &^ p) | q), // 5  0101 Proposition Q
		(p ^ q),        // 6  0110 Exclusive disjunction (XOR)
		(p | q),        // 7  0111 Disjunction (OR)
		^(p | q),       // 8  1000 Joint denial (NOR, Quine's dagger)
		^(p ^ q),       // 9  1001 Biconditional (IFF, <->)
		((p | ^p) ^ q), // 10 1010 Negation of Q
		(p | ^q),       // 11 1011 Converse implication
		(p ^ (^q | q)), // 12 1100 Negation of P
		(^p | q),       // 13 1101 Material implication (->)
		^(p & q),       // 14 1110 Alternative denial (NAND, Sheffer stroke)
		(p | ^p | q),   // 15 1111 Tautology
	)
}

func B1(bs ...uint8) { // Prints last 2 bits
	for _, b := range bs {
		b &^= 1<<8 - 1<<2
		fmt.Printf("%d\t%s\n", b, digits(b)[6:8])
	}
}

func B2(bs ...uint8) { // Prints last 4 bits
	for _, b := range bs {
		b &^= 1<<8 - 1<<4
		fmt.Printf("%d\t%s\n", b, digits(b)[4:8])
	}
}

func digits(b uint8) string { // 8 digits, "%#b" doesn't exist (yet)
	s := fmt.Sprintf("%b", b)
	for i := 8 - len(s); i > 0; i-- {
		s = "0" + s
	}
	return s
}

Categories: Filosofia, Informática Tags:

Configurando CGI no Snow Leopard

June 20th, 2010 No comments

Common Gateway Interface é uma tecnologia que permite criar páginas web dinâmicas com (quase) qualquer linguagem de programação.

Preliminares

Verifique se seu servidor Apache está ativo. Abra um navegador qualquer em http://localhost e deverá aparecer “It works” (no Snow Leopard). A URL http://localhost/~username/ deve mostrar uma página mais bonitinha de título “Your website.” (se você ainda não houver alterado essas páginas).

Se não aparecer nada disso, você tem de ativá-lo. Clique na maçã no canto da tela, vá em System Preferences (Preferências do Sistema) e em Sharing (Compartilhado). Clique em Web Sharing (Compartilhamento Web) e deve aparecer uma bolinha verde indiciando que o servidor está ativo. Aproveite para ver que é mostrado seu IP na rede. É esse endereço que as demais pessoas da rede devem acessar no navegador se quiserem ver o site que você está hospedando na porta 80.

Quando você precisar reiniciar o Apache, você pode desmarcar e marcar novamente o compartilhamento ou pelo comando no terminal (fornecendo a senha root quando solicitada):

sudo apachectl restart

CGI padrão

Costuma-se usar um alias (que encontra-se em /etc/apache2/httpd.conf, linha 328) dos endereços que começam por cgi-bin/ para um diretório restrito onde ficam os arquivos CGI. No Snow Leopard, vc acessa, por exemplo, http://localhost/cgi-bin/script.cgi e o arquivo que será executado será /Library/WebServer/CGI-Executables/script.cgi. Isso evita que, havendo algum erro no servidor, o arquivo seja baixado em vez de executado, o que geraria problemas de segurança (imagine se o arquivo contiver a senha da base da dados).

Essa opção já vem habilitada por padrão, apenas crie um arquivo CGI como os exemplos ao final do post, coloque-o na pasta /Library/WebServer/CGI-Executables/ e dê permissão de execussão do arquivo pelo terminal com o comando:

sudo chmod +x /Library/WebServer/CGI-Executables/meu_arquivo.cgi

Então acesse no navegador http://localhost/cgi-bin/meu_arquivo.cgi para vê-lo rodando.

CGI em Sites/

Mas às vezes você simplesmente precisa de algo mais prático, vamos então habilitar que qualquer arquivo de extensão .cgi na pasta Sites seja executado onde estiver.

Configure o arquivo /etc/apache2/users/username.conf dessa maneira (trocando sempre username pelo seu nome de usuário):

<Directory "/Users/username/Sites/">
    Options Indexes ExecCGI MultiViews FollowSymLinks
    AddHandler cgi-script .cgi
    AllowOverride All
    Order allow,deny
    Allow from all
    <IfModule dir_module>
        # Esse condicional não é necessário, mas é interessante,
        # ele faz com que também index.cgi possa ser índice, isto
        # é, seja a resposta ao solicitar a URL de seu diretório.
        DirectoryIndex index.html index.cgi
    </IfModule>
</Directory>

Virtual host

Podemos aproveitar e configurar um virtual host (um endereço [DNS], no caso http://devel, que é acessível por você e para quem você estiver servindo). No caso, usaremos apenas para o desenvolvimento local de websites em CGI. Crie um arquivo de nome qualquer (com extensão .conf) na mesma pasta do arquivo anterior, por exemplo /etc/apache2/users/devel.conf com o seguinte conteúdo:

<Virtualhost *:80>
    # Onde o root do site se encontra no sistema:
    DocumentRoot /Users/username/Sites/devel
    # Endereço URL pelo qual será acessível:
    ServerName devel
</Virtualhost>

E para que esse endereço seja visto como local, edite o arquivo /etc/hosts com seu editor preferido adicionando ao final:

# Desenvolvimento http://devel
127.0.0.1	devel

Para abrir o arquivo no editor padrão use o comando:

open /etc/hosts

Será requerida a senha de root ao salvar. Teste com um arquivo .html ou .cgi em http://devel.

Exemplos de arquivos CGI

Lembre-se de alguns detalhes:

  • Se a linguagem usada for interpretada, a primeira linha deve apresentar o caminho para o interpretador (ou com env) precedido de #!
  • Você deve sempre imprimir primeiramente o header (como o Content-Type) seguido de duas quebras de linha antes do conteúdo
  • Você deve tornar o arquivo executável (chmod +x)

[Os exemplos a seguir não estão otimizados, são apenas ilustrativos].

Bash

#!/bin/bash
# hello_bash.cgi

echo "Content-Type: text/html"
echo
echo "<html>"
echo "<body>"
echo "<h1>Hello Bash!</h1>"
echo "</body>"
echo "</html>"

Ruby

#!/usr/bin/env ruby
# hello_ruby.cgi

puts "Content-Type: text/html"
puts
puts "<html>"
puts "<body>"
puts "<h1>Hello Ruby!</h1>"
puts "</body>"
puts "</html>"

C

#include <stdio.h>

int main (void)
{
	printf("Content-Type: text/html\r\n");
	printf("\r\n");
	printf("<html>\n");
	printf("<body>\n");
	printf("<h1>Hello C!</h1>\n");
	printf("</body>\n");
	printf("</html>\n");
	return 0;
}

Go

package main 

import "os"

func main() {
	s := "Content-Type: text/html\r\n"
	s += "\r\n"
	s += "<html>\n"
	s += "<body>\n"
	s += "<h1>Hello Go!</h1>\n"
	s += "</body>\n"
	s += "</html>\n"
	os.Stdout.WriteString(s)
}

Divirta-se!

Categories: Informática Tags:

Academia vs Emancipação Educacional

June 12th, 2010 No comments

Em vias de terminar minha graduação, sinto-me impelido a louvar o fim. Digo, não porque terminei, eu, o curso, mas porque acabou-se, ela, a educação acadêmica. Faliu, ruiu, “findou-se a finalidade”, expirou-se a validade, pulverizaram-se as justificativas para esse monumento ao suplício intelectual. Queria meu dinheiro de volta, meus cinco anos de volta ou uma indenização por danos intelectuais. Se pudesse voltar no tempo, haveria investido em ensino a distância, pois quem sabe manter distância do ensino me resguardasse de seus danos. Mas dessa vez, não me refiro a nosso propriamente lastimável paisinho ou a uma local instituição, mas a um absurdo global.

Quando a Academia fundou-se em Platão, foi formulada de maneira a tornar o saber mais acessível do que sem ela (tanto o já conhecido como o que se haveria de desvelar) com os recursos de sua época. Ouso dizer que se Platão tivesse diante de si um computador com Internet, não hesitaria em fazer dele bom uso e promover uma dialética global. Mas a intenção de sua Academia degenerou-se… Agora ela é um lugar onde o saber é sofrido em vez de aprendido: deixou de ser o melhor acesso disponível ao saber e tornou-se um rito de passagem para a vida mercadológica; mergulhou-se numa falsa burocracia por conta da qual o homem nunca esteve tão distante de um saber tão próximo por outras vias.

A fim de garantir a mais-valia, a academia não só deixa de proporcionar o melhor acesso ao saber e ao pensar, mas também milita contra a emancipação da educação pela Internet. Não apenas deixa de usar os melhores recursos para disseminação das informações (computador, data show, intra e internet) como também não incentiva ou mesmo desqualifica projetos Wiki (Wikipédia, Wikicionário, Wikilivros, Wikiversidade) e afins.

Mas é claro que já que a emancipação é um tanto inevitável, uma tendência, digamos, “teleológica” do saber, é preciso fingir que os novos recursos foram apropriados pela academia, ou ficaria óbvio seu papel anti-educacional. Por outro lado, se os novos recursos fossem legitimamente assimilados, aí ficaria óbvio que os alunos não precisam mais de academia alguma senão para conseguir certificação legal e reconhecida no mercado do saber. Ou seja, que a certificação acadêmica é só uma outra versão do papel-moeda… E é. É preciso inflacionar o capital financeiro e deflacionar o capital intelectual, pois é no primeiro que se baseia nosso atual sistema econômico e os que dele mais se beneficiam (e o regem, é óbvio). [Vale lembrar que Economia é de bens e serviços, não a reduza ao plano financeiro].

Fique claro, meu discurso não é Maxista (detesto sua subjetividade pré-definida e monetizada felicidade), mas sou favorável à socialização do saber. Afinal, custaria tanto para o Estado dispor na Internet o material de estudo de todos os cursos acadêmicos? Por que tem isso de ficar a cargo da iniciativa privada?

Gostaria que houvesse uma instituição que só desse certificação sem “tentar ensinar” nada, sério. Imagine você poder estudar do seu jeito (mas com a referência da bibliografia base definida pela instituição) e então ir só fazer a prova (ou outras formas de avaliação) e ganhar o diploma?

“Ah, mas assim é muito fácil!” Porra, é essa a idéia! Não é pra ser difícil, é pra garantir que você sabe, apenas isso. Tá vendo como é rito de passagem? A gente acha cruel aquelas tribos que botam adolescentes pra mexer em colmeias para levar picadas e se tornarem “adultos”, mas não acha cruel colocar crianças e jovens décadas a fio em ruínas educacionais, aprendendo de maneira extremamente ineficaz, sendo punidas quando não se adequam, quando poderia ser fácil e divertido como um videogame, e ainda brigar com eles quando preferem ficar no computador em vez de estudar… Fala séeeerio!

Atualização 29/10/2010

O reitor (Doutor em direito João Grandino Rodas) da Universidade de São Paulo (USP), uma notável instituição de ensino do país, dá entrevista à Veja, concordando muito, a meu ver,  o com o conteúdo desse post e aponta alguns outros problemas sérios…

As universidades Brasileiras parecem amarradas pelos sindicalistas ou, quando não, pela ideologia subjacente a esses. Essa tradição pseudo-marxista luta de toda forma contra o desenvolvimento por entender a “meritocracia” como algo ruim e qualquer tentativa da universidade de se afinizar com o mercado é vista como “ameaça de privatização” (como aquele terrorismo no horário eleitoral). Assim, impedida de angariar investimento privado para promover a pesquisa, continua se apoiando desnecessariamente em impostos, no suor do contribuinte que muitas vezes nem está ligado à instituição. Trata-se dos idiotas de sempre… Diabolizam qualquer interesse empresarial e não concebem a possibilidade de o investimento em pesquisa ser algo bom para todo mundo. Cara, não há interesse do mercado destruir a Academia… (Eles querem gente qualificada). Ela própria parece estar perseguindo esse fim, obstinadamente, a ponto de o mercado ter de ignorar o diploma em favor de outros parâmetros.

Sabemos disso. No meu período no IFCS pude perceber a quantidade de gente medíocre em meio a poucos gênios (os quais considero realmente admiráveis) que fazem nada senão ficar encaixando velhas falácias socialistas em todos os eventos que se lhe apresentam e falar mal de qualquer um, em exercício ou ainda meramente capaz, de liderar ou promover qualquer ação efetiva no mundo real que não possa ser convertida num aforismo ridículo. E como toda boa religião, o socialismo se contorce à vontade em paradoxos tentando neutralizar ou se esquivar de qualquer evidência de eu erro em vez de aprimorar-se até mesmo jogando-se jocosamente das bordas da cognoscibilidade na falta de recurso último. Dogmáticos para umas coisas e céticos para outras… isto é, cínicos, desonestos.

[Aliás aproveito para dizer que não sou socialista ou capitalista (nem de centro), porque meu foco é outro. Ambos são sistemas econômicos - e não políticos - orietados ao capital financeiro. Mas economia e a política só fazem sentido se orientadas a idéias, recursos e valores (como entidades necessárias da ontologia da coisa). É uma ideia que eu gostaria de discutir melhor num post futuro, mas em linhas gerais traz ao gerenciamento do capital como algo inerente, mas secundário em vista o exercício pleno da atividade humana, propriamente humana. Não se trata de capitalizar ou distribuir o dinheiro, ele é sempre uma ficção útil (sempre orientado ao bem de alguém, de algum grupo ou, preferencialmente, da sociedade, e não "gera desigualdade", mas a evidencia), são ações do Estado, isto é, uma representação essencialmente relacional  da disposição de um indivíduo/grupo/instituição para com os demais e vice-versa. (Não é um pleonasmo, as representações são, em muito, socialmente relacionais, mas nem sempre consiste nisso sua essência. E há inclusive representações psicológicas não sociais). Basta notar que ele muda de valor a depender da disposição para obtê-lo (e da quantidade de unidades em giro) e também que sempre há uma ética (provavelmente hoje equivocada e caduca) pressuposta na economia. Não seria uma utopia ingênua... explico depois.]

Em suma, os inimigos da Academia transcendem a esfera acadêmica. Ao que parece, situação e oposição são o inimigo (até porque agora são o mesmo). É hora de mudar a forma de aprender, ensinar, pesquisar (mas certificar com rigor) por uma educação de escopo aberto, autônoma, acessível a todos via Internet e tecnologia. Eis o mar aberto… para além dos tentáculos do presidente molusco avesso à razão.

Categories: Filosofia, Informática, Psicologia Tags: