quarta-feira, 7 de março de 2012

Codifique livre ou morra(): Porque Hackers geralmente são libertários

Daniel Franke,(traduzido por Eduardo Bellani)


Para qualquer um que tenha habitado a internet por tempo suficiente para
diferenciar ICANN de 4chan ou um netcat de um LOLcat, não vai ser novidade que
hackers são com freqüência libertários. A razão é normalmente entendiada como
algo assim: hackers, por definição, gostam de coisas esquisitas, como desmontar
o tocador de DVD ou pesquisar como uma bomba nuclear funciona. Legisladores, que
falham cronicamente em entender o porque alguém iria gostar dessas coisas ou
porque que elas teriam valor pra alguém, passam leis que interferem com essas
atividades. Justificadamente irados, hackers adotam visões políticas que se
opõem a estas intrusões.

A mais clara exposição deste modelo talvez seja o artigo de 2004 do Paul Graham
chamado "A palavra `hacker'". A idéia geral entretanto já está tacitamente
entendida a muito mais tempo. Ela é a base para o tom de várias histórias do
site Slashdot. Observações da correlação hacker-libertário é ainda mais
antiga; não da pra ler USENET antiga por 10 minutos sem perceber-la.

A rescrição de Gordon ao corolário de Newman sobre a lei de Godwin observa
"Libertarismo (pro, contra, e lutas entre as facções) é o tópico primordial
de discussões do net.news. Qualquer hora que o debate muda para outro lugar, ele
precisa eventualmente voltar a esta fonte de combustível" (Não sei quando isto
foi escrito. Não foi entes de 1990 que a lei de Godwin foi criada, e não depois
de 1994 que Godwin a citou).

Hackers tem uma longa história de conflitos com governo. Uma lista incompleta:


  • 1986: O ``Computer Fraud and Abuse Act" passa no congresso americano,
    tornando pela primeira vez cracking um crime. Enquanto ele é direcionado
    principalmente a crimes não controversos, abuso legal por autoridades
    ignorantes por atos perfeitamente legais como port-scanning se torna
    rotina na década de 90.

  • 1993: Philip Zimmerman é o alvo de uma investigação criminal depois que o
    PGP é sai dos Estados Unidos, em violação de restrições de exportação para
    criptografia (que era classificada como munição na época).

  • 1996: O ``Communications Decency Act" restringe severamente material
    "obsceno ou indecente" na internet. Esta lei é negada pela Suprema Corte
    dos Estados Unidos no ano seguinte

  • 1998: O ``Digital Millennium Copyright Act" passa, tornando crime qualquer
    tentativa de passar pelas medidas de segurança que tem como objetivo proteger
    material com copyright, independentemente da intenção do tentativa.

  • 1999: Jon Johansen et. al. libera o DeCSS, decodificando a `encriptação'
    ridícula usado praticamente em todos os DVDs e tornando possível assistir
    DVDs usando software open-source. No ano seguinte, a casa de Johansen é
    invadida pela polícia Norueguesa.

  • 1999: Amazon recebe a notória patente do 1-click.

  • 2000: 72 pessoas na Califórnia recebem uma intimação proibindo-as de usar
    uma camiseta contendo o código de uma parte do DeCSS.

  • 2001: Dimitry Sklyrov, um programador russo visitando os Estados Unidos, é
    preso pela lei DMCA e detido por vários meses por ter escrito um leitor
    de e-book capaz de ler vários formatos com DRM.

  • 2002: Sarbanes-Oxley torna quase impossível para pequenas startups web
    fazerem abertura de ações

  • 2003: A saga legal da SCO começa. SCO exige que todos os usuários Linux a
    paguem $700 dólares de licença.

  • 2003: O FBI invoca abusivamente o USA PATRIOT ACT para recuperar
    notas de repórteres que entrevistaram Adrian Lamo.

  • 2004: No que Brad Templeton descreve como `spamlitigação', o RIAA começa a
    processar seus clientes em massa, distribuindo mais de 20000 processos
    legais, incluindo crianças, avós e falecidos entre os acusados.

  • 2005: FEC Commissioner Bradley Smith afirma que `a exceção da imprensa' do
    McCain-Feingold Campaign Finance Reform Act não inclui bloggers.


Entretanto, estes casos são insuficientes para explicar as atitudes dos hackers.
A cultura hacker existe desde que as universidades tiveram acesso aos
computadores - desde os anos 60 - e mesmo antes era reconhecida pela sua
incarnação anterior dos operadores de rádio amador. Foi uma cultura libertária
desde sua concepção. Mesmo assim, a lista começa em 1986. Antes do CFAA, era
difícil apontar para qualquer intrusão que incomodasse os hackers em particular.
Uso civil dos computadores não estava no radar do congresso e da polícia até
então.

Para não fazer injustiça a tese de Graham, ela é muito mais abrangente que
qualquer lista de reclamações. Graham observa corretamente que hackers tem suspeita de toda a autoridade, mesmo
onde a teoria libertária diz que esta autoridade é legítima. Hackers ficam tão
nervosos com o chefe que controla seu departamento fala para eles que "Eu
acabo de ler numa revista sobre algo chamado virtualização. Nós deveríamos usar
isso." quanto vão ficar com algum agente do governo. Por isso os hackers já se
incomodavam bastante antes de 1986. O governo chegou tarde para essa festa.

Mas a obvervação que hackers são um grupo de espertinhos reclamações não explica o
porque disto. Se as reclamações não se limitam a intersecção entre governo e
tecnologia, porque esta atitude tem relação com escrever código?

A resposta de Graham a isto é a seguinte:

Deixe-me colocar isto em termos que um oficial do governo iria apreciar.
As liberdades civis não são apenas um ornamento, ou uma velha tradição
americana. Liberdades civis fazem os países enriquecerem. Se você fizer um
gráfico de PIB per capita vs liberdades civis, você verá uma forte
relação. Poderia tais liberdades serem a causa, ao invés da conseqüência
da riqueza? Eu penso que sim. Eu penso que uma sociedade em que as pessoas
podem dizer e fazer o que quiserem irá ser uma onde as soluções mais
eficientes venceriam, ao invés daquelas que fossem patrocinadas pelas
pessoas mais poderosas. Países autoritários se tornam corruptos, países
corruptos se tornam pobres, e países pobres se tornam fracos. Parece que
existe uma curva Laffer para o poder do governo, assim como para impostos.
No mínimo, é provável o suficiente para não se tentar um experimento para
testar a hipótese. Ao contrário de impostos, você não pode repelir o
totalitarismo se ele não funcionar direito.

É por isso que os hackers se preocupam. O governo espionando as pessoas
não faz com que o código que eles escrevem se torne pior. Ele apenas leva
a um mundo onde as idéias ruins vencem. E por causa que isto é tão
importante para os hackers, eles são especialmente sensíveis a isto. Eles
podem sentir o autoritarismo se aproximando a distância, como animais
podem sentir uma tempestade.

Eu acho que isto é uma falácia petitio
principii
. É uma visão libertária
sobre o porque os hackers deveriam ser libertários. Se alguém concorda com a
premissa que as liberdades civis fazem as pessoas enriquecerem, então tudo seque
tranqüilamente. Mas se o governo autoritário "não faz com que o código que eles
escrevem se torne pior", então porque hackers tem uma chance maior de fazer esta
conexão?

Uma resposta tentadoramente lisonjeira para esta pergunta vêm do post de 1992 de
Stuart Reges. Resumidamente, Reges afirma que existem uma certa habilidade
mental - "QI libertário" - que nos faz melhores em formar modelos mentais de
como programas funcionam assim como formular como a sociedade funciona. A
primeira habilidade nos faz bons hackers. A segunda nos da um entendimento
intuitivo de como o libertarismo funciona.

Apesar de cortês, eu acho que este argumento erra o ponto da discussão. Toda a
teoria econômica que vem junto com o libertarismo é um efeito secundário.
Libertarismo não é sobre o que nos faz ricos; é sobre o que é certo.
``We hold these truths to be self-evident''

e tudo mais. Libertários não se opões ao governo porque é atrapalhado e
ineficiente, se opõe porque é maligno.

Além disso, acho que Reges nos dá muito crédito. O conhecimento médio dos
hackers sobre a escola Austríaca ou a de Chicago é mais medíocre do que eles se
permitiriam em qualquer assunto técnico. Comece a falar de externalidades ou o
problema do
parasita

e nós mudaremos de assunto.
Claro, os mais sofisticados irão citar o Teorema de
Coase
, mas a maioria nem
ouviu falar dele.

Eu acho que nós estivemos olhando para o problema do ângulo errado.
Não é que hackers adotam políticas libertárias, nem que existe um terceiro fator
que influencia libertários e hackers. Ao invés disso, pessoas com uma atitude
anti autoritária tendem a serem atraídos para programação.

A frase "conhecimento é poder" é um clichê, mas é também verdadeira num sentido
bem literal. Aquilo que você não entende tem poder sobre você. As pessoas que
não tem interesse em entender os computadores estão totalmente acostumadas a
serem mandadas por eles; é mais um fato da vida. Se você não sabe que você pode
mudar o bit de apenas-leitura ao clicar com o botão direito e editar o atributo
na janela de propriedades, então não ter a permissão de editar o arquivo não é
fundamentalmente diferente de não ser capaz de tocar um arquivo .wma cifrado
porque a Microsoft fechou seu servidor de licença. Tentar fazer com que pessoas
leigas se importem com DRM é inútil. Eles são sujeitos as tiranias de seus
computadores todo o tempo. Porque esta seria pior?

Mas para aqueles de temperamento libertário, isso é um estado inaceitável. Ser
mandado pelo governo já é ruim o suficiente. Mas ser mandado por um objeto
inanimado? Intolerável. Como eu posso controlar essa coisa?

Este modelo da psiquê humana explica bastante nossas idiossincrasias de
personalidade. Quando você não tolera ser ignorante sobre uma tecnologia,
aprender sobre ela é a única saída. A outra é se tornar um
ludita. Hackers se tornam
luditas com freqüência.

Para exemplificar, eu tenho o mais barato celular do mercado. Ele não pode nem
fazer o download de tons. Mas é ótimo para fazer chamadas. Porque é isso que
eles tem que fazer. Eles não são feitos para mandar email. Nem para jogar
tetris. Nem para tirar fotos. São feitos para fazer chamadas. É bastante chato
ter que descobrir como tirar meu telefone do modo de câmera. Eu não quero
descobrir como tirar meu telefone do modo de câmera, porque telefones não são
feitos para tirar fotos. São feitos para fazer chamadas.

Algumas pessoas riem dessa atitude, mas é o mesmo sentimento que hackers tem
quando reclamam de inchaço de software. Todos já escutamos, se já não tivermos
participado, de conversas como:

``Eu não quero que meu editor de texto leia email! Eu quero um editor de
texto!''

``Então use-o como um editor de texto.''

``Mas ai vou ficar com todo esse lixo espalhado no meu computador.''

``Por quê você não ignora isso? Não está nem exposto na interface gráfica.
Você tem que saber o comando correto para ativá-lo. São menos de 80MB de
espaço, e você tem 1TB no seu disco, e a maior parte não chega na RAM até
que você a invoca.''

``Mas é nojento!''

Pode parecer forçado chamar a atitude dos odiadores do emacs de ludismo, e mais
forçado ainda chamá-lo de libertária. Mas a psicologia é a mesma. Ninguém quer
tirar o tempo para entender alguma coisa que eles consideram supérflua.
Racionalmente ou não, hackers irão encontrar qualquer tecnologia que eles não
entendem com suspeita - não de seus mérito, mas de sua segurança. "I eu quero
isso ai ferrando com meu sistema", nós iremos dizer para você, mesmo sabendo
perfeitamente bem que ele irá apenas sentar em um canto do disco rígido. Já
recompilou seu kernel apenas para desabilitar um módulo que você não necessita?
A maior pare de nós já o fez, mas isso desafia qualquer base racional.

Mas essa irracionalidade é comum. As atitudes libertárias geralmente ultrapassam
os princípios libertários. Essencialmente todos os libertários defendem o
direito de portar armas, mas consideram o direito a propriedade privada mais
fundamental. Então, nós compreendemos o direito do de proprietários de proibir
armas em sua propriedade. Mas isso não impede libertários de ficarem perturbados
cada vez que um proprietário exerce esse direito.

Ficamos perturbados com os hoplofóbicos (medo de armas de fogo) pela mesma razão
que arrancamos aquele módulo do kernel: odiamos e tememos sermos controlados.

domingo, 26 de fevereiro de 2012

Python, TCO, paradigms, and online classes

I was working on some code for udacity's class and I have been bitten by something interesting, python's lack of TCO.

I know you can do the "same" things without it, but it was pretty
interesting to realize that I am nowadays so used to work with
functional languages that recursion is one of my first tools to
express loops.

Expressing things in imperative ways is taking me more time now, and I
begin to see how different paradigms really leave an impression on
you. Strange and interesting...

quarta-feira, 8 de fevereiro de 2012

Clojure composition and spirit binding

These days I had to craft something that I didn't even knew existed (don't you love when this happens?). Number composition is the name of the spirit this time.

I will paste the algorithm in clojure below, but I guess the most important thing regarding spirits is not the ritual to bind them, but how you find their names so you can research the ritual itself. My favorite source of arcana regarding spirit names is [1]. I advice it to any wizard, be they apprendice or warlock.

Well, here it goes my version of the ritual, hope you enjoy it.




(defn generate-compositions [num]
  "Returns all possible valid partitions of an integer. An useful
references:

* Skiena's The Algorithm Design Manual, section 14.6 Generating Partitions.

* http://code.activestate.com/recipes/218332/

* http://stackoverflow.com/questions/8375439/composition-algorithm-in-javascript-to-return-all-possible-compositions-of-a-num

This will run in O(2^n), so take care with large inputs."
  (defn accumulate-reduced-compositions
    ([composition-set]
       (accumulate-reduced-compositions composition-set 0 [] (count composition-set)))
    ([composition-set index acc set-lenght]
       (let [next-index (inc index)]
         (if (>= next-index set-lenght)
           acc
           (recur composition-set
                  next-index
                  (conj acc (into (conj (subvec composition-set 0 index)
                                        (+ (nth composition-set index)
                                           (nth composition-set next-index)))
                                  (subvec composition-set (inc next-index))))
                  set-lenght)))))
  
  (loop [all-compositions [(vec (repeat num 1))]
         new-compositions (accumulate-reduced-compositions (first all-compositions))]
    (let [first-new-composition (first new-compositions)]
      (if (= 1 (count first-new-composition))
        (set (conj all-compositions first-new-composition))
        (recur (into all-compositions new-compositions)
               (reduce into (map accumulate-reduced-compositions new-compositions)))))))


[1] Steven Skiena: The Algorithm Design Manual

sábado, 24 de dezembro de 2011

Return to blogging, updates and a first glance look at clojure.

Hello dear internet, it's been a year, I have missed you.

This year has been a very interesting one. I have got a job as a
researcher and technical leader, have been professionally programming
in lisp for artificial intelligence projects, built a concurrent
crawler using racket, started using clojure to integrate with java
projects, and more important, have met some very interesting people.

First, let me tell you about lisp in a professional setting. Simply
put, it rocks. Common lisp+slime is a stupendous development
environment. The ecosystem is very alive, albeit not very organized. I
have to remind myself to publish a small article about how to get to
speed with emacs + slime. It really does pays off.

Racket is without a doubt the best language I have explored so
far. The documentation is top notch, the community is full of
intelligent and helpful people, and there is a slime-like plugin
called geiser that is very nice. On a personal note, It was the first
time I have developed a system using an actor like threading system
(racket has mailbox threading). I must say that it has changed the way
I thing about concurrency.

The last technical note is about clojure. It is very nice, specially
if you have to cooperate with the JVM, something that is very probable
if you are interfacing with big corp. It is a modern language,
embracing concurrency and parallelism, is immutable by default, and at
the same time is a lisp. I encourage anyone who wants to learn
something deep and at the same time "practical", considering the JV.

We can never forget that life is about people, and I have met some
incredible people. Crazy, happy, high, depressed, strange, and
interesting people. Because of them, I have got a bit into security
again, learned more about myself and my emotions, entrepreneurship,
martial arts, Austrian economics, anarchism, and much much more. For
all of you, my deep sincere thanks.

Thanks again everyone, I sorry that I have been away for so long. I'll
try harder this time. Merry Christmas!

segunda-feira, 13 de dezembro de 2010

How many fume cupboards are needed? -- Scheme version




I am going through Principles of Statistics in order to build a more respectable statistical knowledge. When I got to problem 2.6 I though it was computational heavy for such a lazy person such as I. Apparently I am not alone in that thinking.

The result is that I ended building a scheme version of the code
found in the above page. It was a very interesting exercise. You
can see the problem and the code below:



#lang racket
;; In a certain survey of the work of chemical research workers, it was
;; found, on the basis of extensive data, that on average each man
;; required no fume cupboard for 60 per cent of his time, one cupboard
;; for 30 per cent and two cupboards for 10 per cent; three or more were
;; never required. If a group of four chemists worked independently of
;; one another, how many fume cupboards should be availabe in order to
;; provode adequate facilities for at least 95 per cent of the time?
(require "cartesian-product.rkt"
         rackunit
         rackunit/text-ui)

(define probability-of-cupboards
  #hash((0 . 0.6)
        (1 . 0.3)
        (2 . 0.1)))


;; how-many-cupboards-for-% : integer number hash -> number
;; given a minimum % and a table of probabilities, find the number of
;; cupboards that will be adequated for the number of people given.
(define (how-many-cupboards-for-% number-of-people
                                  minimum-%
                                  table-of-probabilities)
  (local [(define possibilities
            (sort (hash-keys table-of-probabilities) <))
          (define (accumulate-trials-probabilities
                   trials
                   accumulated-probabilities)
            (if (empty? trials)
                accumulated-probabilities
                (accumulate-trials-probabilities
                 (rest trials)
                 (update-or-insert-probability
                  accumulated-probabilities
                  (foldl (λ (x y)
                            (+ x y))
                         0 (first trials))
                  (foldl (λ (trial-event probability-of-trial)
                            (* (hash-ref table-of-probabilities
                                         trial-event)
                               probability-of-trial))
                         1.0 (first trials))))))]
         (probability-table->result-with-%-greater-than 
          (accumulate-trials-probabilities
           (cartesian-product (make-list number-of-people possibilities)) (hash))
          minimum-%)))

;; probability-table->result-with-%-greater-than : hash number -> number or false
;; takes a probability table with the accumulated results, adds up then
;; in sequence until it surpasses the threshold. False if there is no it never
;; surpasses the threshold. 
(define (probability-table->result-with-%-greater-than table minimum-%)
  (define (accumulate-result list-of-possibilities
                             acc-probability
                             (last-probability #f))
    (cond ((empty? list-of-possibilities)
           (if (< acc-probability minimum-%) #f last-probability))
          ((> acc-probability minimum-%) last-probability)
          (else (accumulate-result (rest list-of-possibilities)
                                   (+ (hash-ref table
                                                (first list-of-possibilities))
                                      acc-probability)
                                   (first list-of-possibilities)))))
  (accumulate-result (sort (hash-keys table) <) 0))

;; update-or-insert-probability : hash integer number -> hash
(define (update-or-insert-probability table
                                      cupboard-number
                                      probability)
  (hash-update table
               cupboard-number
               (λ (old-probability)
                  (+ old-probability probability))
               0))

(define-test-suite cupboards
  (check-equal? (how-many-cupboards-for-% 4 0.95 probability-of-cupboards) 4)

  (check-equal? (probability-table->result-with-%-greater-than 
                 #hash((0 . 0.1296)
                       (1 . 0.2592)
                       (2 . 0.2808)
                       (3 . 0.1944)
                       (4 . 0.094)
                       (5 . 0.0324)) 0.94)
                4)
  (check-equal? (probability-table->result-with-%-greater-than 
                 #hash() 0.0)
                #f)
  (check-equal? (probability-table->result-with-%-greater-than 
                 #hash((0 . 0.4)
                       (1 . 0.2)) 0.7)
                #f))

(run-tests cupboards)

terça-feira, 7 de dezembro de 2010

Functional Round-Robin scheduler in Common Lisp



A while ago I posted a robin-round tournament scheduler in ruby. Since I am going
through PAIP, I thought to give a functional common lisp version a go.



In my opinion it is more readable and flexible, but I would
attribute that to better design and experience than the
language. But CL's list utilities sure helped.


;;;; round-robin.lisp

(defpackage :round-robin
  (:use :cl :lisp-unit))

(in-package :round-robin)

;; rotate-list-left : (listof X) integer -> (listof X)
(defun rotate-list-left (a-list how-many-moves)
  "rotate the list how-many-moves to the left"
  (if (zerop how-many-moves)
      a-list
      (rotate-list-left (append (rest a-list)
                                (list (first a-list)))
                        (1- how-many-moves))))

;; make-matches : (listof X) -> (listof X)
(defun make-matches (players)
  (if (null players)
      nil
      (cons (cons (first players)
                  (last players))
            (make-matches (butlast (rest players))))))

;; print-matches : (listof (listof X)) -> nil
(defun print-matches (matches)
  (if (null matches)
      nil
      (progn
        (let ((current-match (first matches)))
          (print (format nil "~a against ~a!"
                         (first current-match)
                         (second current-match))))
        (print-matches (rest matches)))))



;; round-robin : (listof X) -> nil
(defun round-robin (players)
  "prints matches in round robin fashion"
  (defun do-matches (full-list-of-players
                     max-number-of-rounds
                     current-round)
    (if (>= current-round max-number-of-rounds)
        nil
        (progn (print-matches
                (make-matches
                 (cons (first full-list-of-players)
                       (rotate-list-left (rest full-list-of-players)
                                         current-round))))
               (do-matches full-list-of-players
                 max-number-of-rounds
                 (1+ current-round)))))
  (let ((full-list (if (zerop (mod (length players) 2))
                       players
                       (append players (list 'DUMMY)))))
    (do-matches full-list (length full-list) 1)))

(define-test round-robin-utilities
  (print-matches '((a f) (b e) (c d))) ;; check output
  (assert-equal (rotate-list-left '(a b c d e f g h) 3)
                '(d e f g h a b c))
  (assert-equal (make-matches '(a b c d e f))
                '((a f) (b e) (c d))))

(define-test round-robin
  (print "Even number of players")
  (round-robin '(a b c d))

  (print "Odd number of players")
  (round-robin '(a b c d e)))

(run-tests)



quinta-feira, 2 de dezembro de 2010

A small view on the history of programming and personal computing

I have just finished a draft of an article that I wanted to write for some time:

A small view on the history of programming and personal computing

Here is a copy of the abstract:

Those who cannot remember the past are condemned to repeat it.
Because programmers usually think they deal with cutting edge tech-
nology, they tend to forget the age and genealogy of the ideas they
are working with. A demonstration of the history of the some crucial
ideas of the programming craft would avoid the repetition of error and
allow better ideas to take hold.

Suggestions and feedback are more than welcome.