Minhas aventuras no fantástico mundo de Haskell

Linguagens e raciocínio

Não cheguei a ler The Pragmatic Programmer, escrito por Andrew Hunt e David Thomas. Ainda assim, existe um conselho desse livro que eu já encontrei inúmeras vezes nos meus estudos de programação:

Learn at least one new language every year. Different languages solve the same problems in different ways. By learning several different approaches, you can help broaden your thinking and avoid getting stuck in a rut. Additionally, learning many languages is far easier now, thanks to the wealth of freely available software on the Internet.

Traduzindo livremente:

Aprenda ao menos uma linguagem de programação a cada ano. Ao aprender várias abordagens diferentes, você amplia a sua forma de pensar e evita cair na mesmice. Além disso, aprender várias linguagens ficou mais fácil, graças à riqueza de softwares gratuitos disponíveis na Internet.

Cada linguagem de programação tem suas particularidades, e essas diferenças acumulam-se nas soluções. Algumas linguagens são bem parecidas (pense em C++, C# e Java), e acabam resultando em soluções parecidas. Nesses casos não há muito o que ganhar. Mas quando decide-se estudar um outro paradigma, aí a história é outra.

Minha caixa de ferramentas

A primeira linguagem que aprendi foi C++, e Java veio logo em seguida. Depois, aprendi Lua. Como trabalho com desenvolvimento Web, tive que estudar PHP e JavaScript. E no meu mestrado precisei de um pouquinho de Python. Estudei a engine Unity há um tempo atrás, então eu também sei C#. A última linguagem que aprendi foi VBScript, quando recebi um sistema ASP legado para dar manutenção.

Existe uma padrão nessa minha lista de linguagens conhecidas: todas são imperativas. E tirando VBScript, todas são baseadas em C. E mesmo VBScript não é tão diferente assim. Se eu estudar uma outra linguagem imperativa, como Ruby por exemplo, certamente vou aprender uma coisa ou outra. Afinal, sempre há muito o que aprender.

Mas o que eu quero é aprender muito. Meu objetivo não é incluir novas ferramentas na minha caixa, mas aprender a trabalhar com ferramentas totalmente alienígenas às que eu conheço. Eu quero pensar de várias formas diferentes. E acho que para isso, preciso aprender outro paradigma. É aí que entram as linguagens funcionais.

Paradigma funcional

O paradigma declarativo é totalmente diferente do imperativo. Programas imperativos são sequencias de instruções que o processador executa. Já os programas declarativos contém uma descrição do que se deseja, e o programador abstrai o procedimento exato. Ao criar um algoritmo declarativo, o programador diz o que o programa é, e não o que ele deve fazer.

Soa bem diferente de todas as linguagens que conheço. Dá para fazer alguns paralelos. Consultas SQL são declarativas por exemplo. CSS também. Mas nenhuma das duas são linguagens de programação. Então, eu não sei programar em nenhuma linguagem declarativa.

O paradigma declarativo é muito amplo, assim como o imperativo também é. Dos subparadigmas declarativos existem dois que me interessam muito: linguagens funcionais e concatenativas. As concatenativas são mais obscuras, e por isso escolhi começar pelas linguagens funcionais.

E quais linguagens são funcionais? Existem inúmeras, e a maioria delas é alguma forma de dialeto do Lisp. Eu tentei aprender Lisp uma vez, usando uma linguagem chamada Racket, mas não deu muito certo. Lisp é como C++: poderosa e feia. Haja parentêses!

A linguagem funcional que realmente chamou minha atenção foi Haskell. Eu tive uma introdução a Haskell na universidade, em 2004. Mas já faz tanto tempo que não consegui aproveitar muita coisa. Tive que começar do zero. E esta é a minha terceira tentativa de aprender Haskell.

As duas primeiras foram muito similares. Tentei aprender a linguagem usando o livro Real World Haskell, que está disponível online. E em nenhuma das duas vezes deu certo. Chegava até o capítulo 6, e daí já não andava muito. Apesar de não ter aprendido a programar em Haskell, aprendi muitos conceitos de programação que para mim (e para todos os meus colegas de trabalho, parece) eram novos. Principalmente funções puras.

Comecei a sempre tentar codificar usando funções puras. Essa prática me ajudou em várias ocasiões, porque muitas das funções que eu codificava tinham um alto potencial de reuso. No ato da codificação, parecia meio bobo deixar uma função sendo pura. Seis meses depois, essa mesma pureza permitia que um recurso completamente novo pudesse ser rapidamente desenvolvido.

Então, apesar de não ter aprendido Haskell nas duas primeiras tentativas, eu aprendi a programar melhor. As duas tentativas não foram dois fracassos. Depois das funções puras, eu estudei um bocado sobre funções de alta ordem. Basicamente, uma linguagem com funções de alta ordem permite que funções sejam passados para outras funções, ou retornados. JavaScript é assim, com suas funções anônimas.

Recentemente, percebi que estava pronto para uma terceira tentativa.

Finalmente, Haskell!

A terceira tentativa tem sido muito diferente da duas primeiras. Agora estou usando outro livro, o Learn You a Haskell for Great Good!, que também está disponível online. Achei esse livro bem mais didático que o Real World Haskell. Os assuntos são introduzidos com calma, as explicações são bem claras, e ele tem muitos exemplos. Não tem exercícios como o Real World Haskell, mas para começar, eu tentava implementar os exemplos antes de ler o código do livro. E além disso, encontrei uma lista com 99 exercícios para iniciantes. Bastante material.

Acho que dessa vez eu peguei o jeito. Não considero que programo em Haskell, porque ainda me confundo demais com exercícios simples. Sem falar que mônades ainda são um mistério para mim. Eu ainda estou aprendendo, e a terceira tentativa continua. Pretendo escrever alguns artigos sobre o assunto no futuro. E vamo que vamo!

Deixe uma resposta

Your email address will not be published / Required fields are marked *