Clojure e simplicidade

AVISO – me empolguei um pouco nessa postagem, para uma introdução mais gentil, verifique o post após esse.

Qualquer linguagem baseada em LISP, como Clojure, tem o mesmo problema: as pessoas falam de como a linguagem é fantástica, como ela revoluciona como você programa, até o momento em que você resolve entender por que. Aí você estuda a linguagem, aprende uma ou outra coisa, e não entende porque as pessoas falam tão bem dela.

Esse ciclo se repete várias vezes, e várias vezes, e você nunca entende o motivo das pessoas falarem tão bem. Até um dia em que você finalmente entende – e é aí que você vira uma dessas pessoas que falam bem, mas ninguém mais entende por que.

Clojure é, basicamente, um LISP que roda sobre a JVM. Porém, diferente de common LISP, Clojure possui duck typing – LISP não. É essa foi a primeira realização – tipagem dinâmica não implica em duck typing.

Ruby, JS, e Clojure possuem métodos (ou keywords, ou funções) que rodam sobre qualquer tipo que atenda aquele protocolo. for element in array, por exemplo, roda em Ruby e JS da mesma maneira para Arrays, ou para Objects (em JS) ou Hash, Set, para Ruby. Em Ruby, é porque todos implementam o método .to_a. Já em Clojure, o nth serve para pegar um elemento de uma coleção qualquer, seja ela uma List ou Vector, usando (nth ["some" "elements"] 1). E como é isso em Common LISP? Bom, se for uma List, usa-se: (nth 1 '("some" "elements")). Se for um Vector, com (aref (vector "some" "elements") 1). E assim por diante (o que quer que isso signifique nessa situação, já que nem posicionamento dos parâmetros nem nome das funções é consistente).

A segunda coisa interessante de Clojure é a sua “sintaxe”, ou na verdade, ausência de sintaxe. Na prática, a sintaxe não existe – você programa definido diretamente as S-Expressions, como se fosse uma lista de comandos. Por exemplo:

; uma definição de uma função
(defn sum-ages [people]
  (reduce + (map :age people)))

; uma definição de uma lista
`(defn sum-ages [people]
   (reduce + (map :age people)))

A segunda expressão, apenas pela presença de um “quote”, torna-se uma lista. O primeiro e segundo elementos são Symbol, o terceiro elemento é um Vector que contém outro Symbol, e o quarto elemento é outra List: (reduce + (map :age people)), e assim as coisas continuam. Symbols, em Clojure, serão convertidos em sintaxe mais cedo ou mais tarde, então defn será clojure.core/defn, e chamará a função, símbolo, ou special-form desse nome mais cedo ou mais tarde. E isso é uma coisa fantástica pelos motivos que veremos a seguir. Mas o primeiro deles é bem óbvio: você não tem códigos – apenas dados. E como a linguagem é composta de dados, podemos manipulá-la, moldá-la, e alterá-la com macros. Além disso, Clojure é uma linguagem muito simples – ao contrário por exemplo, de Ruby, aonde a linguagem é complexa, mas programar nela é simples, em Clojure a linguagem é simples, mas programar nela é um pouco mais complicado.

E o motivo, por mais absurdo que pareça, é que nós, programadores, aprendemos a programar de forma errada
(more…)

Orientado a Objetos versus Funcional

Bom, esses dias estava estudando Scala. Uma linguagem multi-paradigma, mas que parece mais “funcional” do que “imperativa”. Scala cai numa posição ainda nebulosa para a maior parte das pessoas (e acho até que para o mercado também). Afinal, imutabilidade é “programação funcional”? Scala não faz nada que impede “side-effects” no código, como Haskell por exemplo, então ela é funcional mesmo?

Como mesmo eu não tenho muitos conhecimentos em linguagens funcionais, resolvi propor um problema para mim mesmo: implementar uma árvore binária em Ruby, e depois portá-la para Scala, tentar uma abordagem imutável em Scala, e depois portar para Haskell. O código está no github, mas algumas coisas vão ser discutidas aqui.

Primeiramente, a árvore imutável é feita recriando a árvore inteira. Claro, não podemos re-criar apenas um nó e apontar, digamos, a referencia de seu pai para esse novo nó, porque o pai é imutável (assim como qualquer outro aspecto do programa).

class Node[A <% Ordered[A]](value: A = None, left: Option[Node[A]] = None, right: Option[Node[A]] = None) {
    def insertNew(newValue: A): Node[A] = value match {
        case v if(newValue < v) => insertLeft(newValue)
        case _ => insertRight(newValue)
    }

    private def insertLeft(newValue: A) = new Node(value, newChild(left, newValue), right)
    private def insertRight(newValue: A) = new Node(value, left, newChild(right, newValue))
    private def newChild(child: Option[Node[A]], newValue: A) = child match {
        case Some(child) => Some(child insertNew newValue)
        case None => Some(new Node(newValue))
    }
}

(more…)

Bytecodes, e JIT

Resolvi escrever este post por muitos motivos, mas o principal deles é porque vi muitos amigos e colegas meus sem saber, direito, o que é um bytecode. Muitos acham que apenas linguagens como Python (com seus arquivos .pyc) e Java (com seus arquivos .class) possuem bytecodes, justamente porque ao “compilar” o programa, um novo arquivo é criado.

Nada poderia estar tão longe da verdade.

Bytecode é um conjunto de instruções, em forma binária ou seja, em uma forma não legível por humanos, que instrui uma máquina virtual a fazer determinadas ações. Bytecode não é apenas um arquivo, ou um código intermediário entre o executável nativo e a linguagem, e na maioria das vezes nem sequer é um código otimizado, com algumas raras exceções (scala 2.8, por exemplo, pode otimizar “tail call” em recursões). É importante entender essa parte, porque nem sempre um bytecode é gravado em um arquivo, e em algumas vezes sequer é um formato simples.
(more…)

Update: o que estou estudando?

Como faz tempo que não posto nada no blog (falta tempo), resolvi fazer este post meio que para iluminar um pouco o que tenho estudado ultimamente.

Comecei a aprender Scala. Na verdade, peguei esse tempo para estudar linguagens interessantes, que há tempos quero estudar como Scala, Haskell e Lisp. Criei um repositório de testes para brincar com essas linguagens no meu github: https://github.com/mauricioszabo/learning. Futuramente, farei posts sobre Scala também, que é uma linguagem interessante para substituir Java.

Comecei também a estudar desenvolvimento para Android. Instalei o emulador, fiz uns “hello, worlds” com Scala, Java e JRuby (Ruboto), o suficiente pra descobrir que rodar algo em Ruboto é inviável de tão lento…
(more…)

Monkey-Patch seguro, em Javascript

Continuando os estudos com Javascript, diversas coisas interessantes, que pareciam acessíveis apenas aos programadores de Ruby, Perl e outras linguagens mais flexíveis podem ser feitas também na linguagem. O problema é que, normalmente, é difícil de usar isso em bibliotecas que já existem, principalmente porque a maioria dos códigos em Javascript ou não seguem boas-práticas ou simplesmente são escritos de forma diferente do que vou apresentar aqui, porém vale pela dica. Um exemplo bem simples, pensando na seguinte API:

objeto = {
  valor: 10,
  incrementar: function(v) { 
    if(!v) v = 1;
    valor += v;
  },
  raizQuadrada: function() {
    Math.sqrt(incrementar(4));
  }
}

Para implementá-la, em Javascript, há várias formas. Simulando o comportamento que eu fiz no post passado, é possível usar o seguinte formato:
(more…)

Estudos com Javascript

Recentemente, comprei o livro Javascript – the Good Parts, do Douglas Crockford. A principal motivação, não vou negar, foi o node.js (e o fato que muitas pessoas na net têm falado de Javascript como uma das mais “novas” maravilhas. Mas isso fica pra outro post). O livro, embora tenha uma série de problemas (e o principal é a ausência de exemplos claros, além de dar pouca ênfase ao “Javascript way”, na minha opinião) é muito bom e traz algumas definições no mínimo diferentes sobre Javascript.

Basicamente, o que é Javascript? Javascript é orientado a objeto? Javascript é funcional? Javascript suporta classes, suporta….?

Para começar, Javascript é uma linguagem de programação com sintaxe semelhante a C++, dinâmica, com tipagem absurdamente fraca, pseudo-orientada a objetos, orientada a protótipos e funcional. Wow… um de cada vez.
(more…)

Ensaio Sobre Tesouras de Plástico sem Ponta

Pode parecer estranho o título deste post, mas na verdade ele não é apenas sobre aquelas tesouras de criança, mas sobre segurança e como ela afeta nossa vida. Mas, para isto, é melhor começar com uma história simples de diferença de cultura:

Na pré-escola, professores e professoras sempre insistiam para usarmos “tesouras sem ponta”, que normalmente significava aquelas tesouras minúsculas com cabo de plástico e que não cortavam nem uma folha de papel direito. Quando você é criança, porém, tudo é divertido (até o fato da tesoura não cortar), e no fim você ou pede emprestada uma tesoura de outra criança, que ainda não perdeu o corte, ou acaba cortando na mão, quando o corte for reto.

Agora, vamos para outra cultura: Japão. Em animes, você normalmente vê crianças e adolescentes com aulas de culinária, prendas domésticas, ou semelhantes. Nestas aulas, os adultos supervisionam, mas são os alunos quem realmente acendem o fogo, usam facas pontudas, etc. A idéia, até onde eu sei, é ensinar desde pequeno como usar uma ferramenta que pode potencialmente ser perigosa, como ensinar a ter cautela.

Imagine, agora, você com trinta anos, um cabeleireiro, estilista, artista plástico, sendo obrigado a usar uma tesoura de plástico sem ponta? Um cozinheiro que precisa de “provadores”, “acendedores de fogão”, porque, ora, no primeiro caso ele pode queimar a língua, no segundo, ele pode explodir o fogão. Ou então, usando o fogão X, porque ele tem um acendedor automático de bocas, e assa um bolo em alguns dias, afinal, com um fogo BEEEM baixo, a chance de queimar o bolo é bem menor… certo? O que isso nos diz? Na minha opinião, tudo se resume a apenas uma palavra:

Confiança.
(more…)

Sistemas de Arquivos em Ruby

Por algum motivo, pensei se isso seria mais uma das “coisas que você nunca quis fazer com Ruby”, mas acho que não, até porque estou num projeto para usar tal funcionalidade. Mas, por via das dúvidas, vamos fazer algo BEM estranho:

Para quem não conhece, o FUSE (Filesystem in Userspace), uma extensão do Kernel do Linux (e do MacOSX, se não me engano), serve principalmente para criar sistemas de arquivo. Isso significa, se você sempre teve vontade de acessar sua base de dados como se fosse uma sequência de diretórios, por exemplo, esse pacote é para você. Mas, como já existem exemplos demais assim, vamos fazer algo mais bizarro (para variar): integrar o Twitter com FUSE.

Para tal tarefa, você precisará das gems “twitter” e “fusefs”. Basta instalá-las com “gem install fusefs twitter”, arregaçar as mangas, e partir para o próximo passo.
(more…)

FISL – Minha palestra, e Code Golf

Pretendo ainda fazer um resumão do FISL, mas por enquanto vamos a palestra e ao Code Golf.

Durante o FISL, apresentei a palestra “Lapidando Ruby”, um estudo de boas práticas em programas Ruby e em Rails. Basicamente, uma apresentação sobre as diversas práticas que eu percebi que levavam a um código melhor. Como eu disse na apresentação, parte do estudo é que as pessoas discordem de algumas coisas que eu faço. Pela reação do pessoal, acho que muitas pessoas concordaram com a maioria do que eu falei. A apresentação está no slideshare, e está abaixo (nota, que é melhor baixar o arquivo do SlideShare, fica um pouco melhor do que a apresentação que eles colocam lá):
(more…)

Traçando a Execução em Bibliotecas de Terceiros (em Ruby)

Ontem, acredito que esbarrei feio num bug do Ruby 1.8 (não sei se outras versões estão com o mesmo problema). Para encurtar a longa história, estava mexendo num código usando TheRubyRacer semelhante ao seguinte (nota: se você não entender o código a seguir, vale a pena dar uma olhada em meu post anterior):

class UmaClasse
  def method_missing(method, *args, &b)
    puts "Método #{method} chamado!"
    ...
  end
end

require 'v8'
context = V8::Context.new
context['classe'] = UmaClasse.new
p context.eval('classe.um_metodo')
p context.eval('classe.um_metodo = 10')

O que eu esperava, é que na linha 11, fosse impressa a mensagem “Método um_metodo chamado!”, porém o que aconteceu não foi bem isso. Quando olhei para a documentação da biblioteca, descobri que ela expõe apenas os métodos públicos por padrão, agora COMO ela fazia isso… isso já é outro problema. Então, num primeiro momento, resolvi remover todos os métodos da classe UmaClasse, e ver o que acontecia:
(more…)