Clojure for the Brave and True

Como desenvolvedor a alguns anos, decidi mergulhar no mundo de LISP através de Clojure por pura curiosidade. E foi assim que encontrei o livro "Clojure for the Brave and True", de Daniel Higginbotham. A primeira coisa que me chamou a atenção foi o tom descontraído e acessível do autor, que consegue tornar conceitos complexos em algo digerível e, muitas vezes, engraçado. Mas será que o livro é só diversão, ou ele realmente entrega conteúdo de qualidade? Vamos analisar.

O que funciona bem

O livro começa com uma introdução leve e bem-humorada, mas não se engane: ele rapidamente mergulha em conceitos profundos. Higginbotham tem um talento especial para explicar ideias complexas de forma clara. Por exemplo, ele introduz o conceito de programação funcional com exemplos práticos que mostram como Clojure lida com imutabilidade e funções de primeira classe.

(defn inc-maker [inc-by]
  #(+ % inc-by))

(def inc3 (inc-maker 3))
(inc3 7) ; => 10

Aqui, o autor não só explica como criar funções que retornam outras funções (closures), mas também mostra como isso pode ser útil em situações reais. Isso é algo que muitos livros técnicos falham em fazer: conectar a teoria à prática.

Um dos pontos fortes do livro é a ênfase em programar para abstrações, não para implementações. Isso é algo que, como desenvolvedor, aprecio profundamente. O autor explica como Clojure trata listas, vetores, conjuntos e mapas como sequências, permitindo que você use funções como map, reduce e filter de forma consistente, independentemente da estrutura de dados.

(map inc [1 2 3]) ; => (2 3 4)
(map inc #{1 2 3}) ; => (2 3 4)

Essa consistência é uma das razões pelas quais Clojure é tão poderoso, e o livro faz um excelente trabalho em destacar isso. Um dos capítulos mais bem escritos do livro é The Sacred Art of Concurrent and Parallel Programming.

Diferente de outros livros introdutórios que tocam na programação concorrente de maneira superficial, Higginbotham realmente se aprofunda nos conceitos, apresentando explicações claras e exemplos práticos que cobrem atoms, refs, agents e core.async.

O livro também fornece uma ótima explicação sobre como evitar condições de concorrência e sincronizar operações concorrentes de forma eficiente. A cobertura de core.async é particularmente útil, pois ensina como estruturar aplicações concorrentes de maneira elegante e escalável. O livro está repleto de exemplos práticos que ajudam a solidificar o aprendizado.

Um dos meus favoritos é o exemplo do "Hobbit Violence", onde o autor cria uma função para simular ataques a um hobbit, escolhendo aleatoriamente uma parte do corpo para atingir. Isso pode parecer bobo, mas é uma maneira eficaz de ensinar conceitos como recursão, lazy sequences e manipulação de mapas.

(defn hit [asym-body-parts]
  (let [sym-parts (better-symmetrize-body-parts asym-body-parts)
        body-part-size-sum (reduce + (map :size sym-parts))
        target (rand body-part-size-sum)]
    (loop [[part & remaining] sym-parts
           accumulated-size (:size part)]
      (if (> accumulated-size target)
        part
        (recur remaining (+ accumulated-size (:size (first remaining))))))))

Esse exemplo não só é divertido, mas também ilustra como Clojure pode ser usado para resolver problemas de forma elegante e concisa.

O que poderia ser melhor

Embora o livro seja excelente para iniciantes, ele pode deixar a desejar para desenvolvedores mais experientes que já estão familiarizados com conceitos de programação funcional. Tópicos como macros e metaprogramação são abordados, mas de forma superficial. Por exemplo, o capítulo sobre macros poderia explorar mais a fundo como criar macros complexas e seguras, em vez de apenas mostrar o básico.

(defmacro unless [test & body]
  `(if (not ~test)
    (do ~@body)))

(unless false (println "This will print!"))

Enquanto o exemplo acima é útil, ele não vai muito além do que você encontraria em uma documentação básica. O livro foca quase exclusivamente na linguagem Clojure em si, mas não dedica muito tempo ao ecossistema ao redor dela, como Leiningen, ClojureScript, ou bibliotecas populares. Para alguém que está começando, entender como gerenciar dependências e construir projetos é tão importante quanto aprender a linguagem.

A seção Advanced Topics do livro apresenta conceitos como Transducers, Multimethods e Protocols, que podem ser úteis para desenvolvedores mais experientes. O problema é que essas explicações são relativamente curtas e não exploram detalhadamente aplicações práticas ou implicações de design.

Os exercícios no final de cada capítulo são úteis, mas muitos deles são bastante simples. Para desenvolvedores experientes, seria interessante ver problemas mais complexos que exigissem uma combinação de conceitos aprendidos ao longo do livro.

Vale a Pena?

Depende da sua experiência na linguagem e no paradigma funcional. Se você é iniciante e está em busca de uma leitura mais descontraída, este livro é para você. Para quem deseja um entendimento profundo da linguagem, especialmente em aspectos como macros e concorrência, o livro pode ser frustrante. Para quem já tem experiência em outras linguagens funcionais ou mesmo em Lisp, o tom descontraído e a falta de profundidade podem ser um obstáculo.

Se você está buscando algo mais sólido, recomendo Clojure Programming de Chas Emerick ou The Joy of Clojure de Fogus e Houser (dois grandes livros dos quais ainda pretendo fazer uma análise futuramente). No final, depende do seu objetivo: se você quer apenas brincar um pouco com Clojure, Clojure for the Brave and True é uma leitura leve e divertida. Mas se você quer uma base séria para construir aplicações reais, melhor buscar outras fontes. Em uma nota de 0 a 10, daria 6 a este livro.