Há alguns meses quando este sentimento veio novamente decidi que iria tentar algo diferente. Foi ai que comecei com o combo título deste post. Uma mudança radical de ares.

Não sou o primeiro e com certeza não serei o último.

Apesar de trabalhar com Windows e depender dele pro meu ganha pão adotei o Ubuntu como sistema operacional padrão deixando o Windows em uma VM [1] apenas para trabalho e comecei a estudar F# que é uma linguagem com paradigma funcional que é completamente diferente de C#, Java e parentes próximos. Não bastasse a mudança de sistema operacional e de paradigma decidi também aprender mais a respeito de shell e editores de texto pra me livrar mais ainda dos atalhos que uma IDE como o VS proporcionam e adotei o VIM como editor de texto.

Nest post vou mostrar como montar um ambiente como o meu e os primeiros (primeiros mesmo, nada avançado) passos nessa estrada de aprendizado. Se tudo der certo e eu não desistir transformo numa série pra poder compartilhar meu aprendizado e com a colaboração de vocês aprender mais sobre o assunto.

Tudo que estou fazendo é no Ubuntu 10.10, mas deve funcionar com uma boa parte dos *nix por ai.

Instalando F# com Mono

Provavelmente o Linux que você tem instalado já deve ter o mono instalado, portanto não precisamos nos preocupar com esta etapa. De qualquer forma, só pra garantir abra o shell (Terminal) veja se você está realmente como o Mono instalado e qual sua versão:

mono -V

Se tudo estiver certo teremos algo parecido com isso:

Mono JIT compiler version 2.6.7 (Debian 2.6.7-3ubuntu1)
Copyright (C) 2002-2010 Novell, Inc and Contributors. www.mono-project.com
    TLS:           __thread
    GC:            Included Boehm (with typed GC and Parallel Mark)
    SIGSEGV:       altstack
    Notifications: epoll
    Architecture:  amd64
    Disabled:      none

Caso ele não esteja instalado basta ir ao Ubuntu Software Center [2] para instalá-lo ou baixá-lo no site oficial.

Com Mono instalado corretamente e acessível de qualquer lugar precisamos agora baixar a última versão disponível da biblioteca e compilador FSharp. Temos três opções para a instalação:

1. Efetuar o download do código fonte, compilá-lo e efetuar a instalação
2. Baixar um pacote cross-platform que faz a instalação de tudo
3. Baixar o pacote oficial compilado, efetuar a instalação e configurar as variáveis de ambiente “manualmente”

Vamos com a terceira opção, pra ver onde vai cada coisa e como cada um dos executáveis funciona.

A última versão disponível no momento deste post é a 2.0.0.0 de Novembro de 2010.

Como somos usuários ninjas de Linux vamos efetuar o download via linha de comando com wget.

wget http://download.microsoft.com/download/4/5/B/45BD9FBC-22BA-4B45-84B7-17D1AD0122A1/fsharp.zip

Terminado o download, um pacote zip, extraimos todo o conteúdo pra uma pasta qualquer.

unzip fsharp.zip

Agora devemos ter todo o conteúdo do zip extraido em uma pasta chamada FSharp-2.0.0.0.

Antes de instalar sugiro mover a pasta com o conteúdo extraido do zip para um local mais apropriado para este tipo de arquivos já que é a partir desta pasta que iremos fazer referência mais pra frente aos executáveis do FSharp. Eu utilizo /usr/lib/ [3]. Além de mover, vamos renomear a pasta de destino apenas para fsharp a fim de deixar tudo mais simples.

sudo mv FSharp-2.0.0.0/ /usr/lib/fsharp/
cd /usr/lib/fsharp/

Agora para instalar basta executar:

cd fsharp
sudo sh install-mono.sh

Este comando provavelmente retornará um erro indicando que a DLL não pôde ser adicionada ao GAC por conta de seu strongname. O que acontece é que a versão compilada que baixamos está com uma assinatura para o .NET Framework do Windows então antes de conseguir instalar o FSharp no Mono devemos baixar um arquivo.snk próprio para ele e ai sim executar novamente o setup.

wget -O mono.snk https://github.com/mono/mono/raw/master/mcs/class/mono.snk --no-check-certificate
sudo sh install-mono.sh

Dando tudo certo, devemos receber uma mensagem de sucesso:

-- Resigning FSharp.Core.dll with mono.snk
Assembly bin/FSharp.Core.dll signed.
-- Installing FSharp DLLS into the GAC
Installed bin/FSharp.Core.dll into the gac (/usr/lib/mono/gac)

Pra testar se tudo der certo, ainda de dentro do diretório onde instalamos o FSharp, podemos executar:

mono bin\fsi.exe

Se tudo estiver OK vamos entrar no FSharp Interactive que é uma console REPL pra F# muito legal:

Microsoft (R) F# 2.0 Interactive build 2.0.0.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

> 

Podemos também fazer o tradicional “Hello World”:

> printfn "Hello World!";;
Hello World!
val it : unit = ()

Pronto!

Tecnicamente temos o FSharp instalado com sucesso e pronto para usar. No entanto, tanto o compilador (fsc.exe) e o REPL (fsi.exe) não fazem parte do PATH configurado em nosso Linux. Desta forma, ele está apenas acessível a partir do diretório onde está localizado.

Pra resolver isso vamos baixar o pacote de ferramentas adicionais para FSharp que irá nos prover algums aliases que permitirão o acesso as ferramentas a partir de qualquer diretório.

Dessa vez, como este pacote está hospedado no Codeplex, temos que efetuar o download do pacote “Additional scripts and tools only (.tgz archive)” manualmente localizado em http://fsxplat.codeplex.com/releases/view/55463.

Feito o download podemos voltar ao nosso querido shell e instalar o pacote de bonus.

cd ~/Downloads
mkdir fsharp-bonus
tar -xvzf fsharp-bonus.tgz -C fsharp-bonus
cd fsharp-bonus
sudo bash install-bonus.sh

Este script de instalação espera que as DLLs do FSharp estejam na pasta /usr/lib/fsharp. No entanto, no nosso caso elas se encontram em /usr/lib/fsharp/bin, portanto caso o script solicite esta informação, fica fácil de prover.

Feito isso é hora de testar e já podemos chamar fsharpi de qualquer lugar no shell:

tucaz@tucaz-nb:~$ fsharpi

Microsoft (R) F# 2.0 Interactive build 2.0.0.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

For help type #help;;

> 

Agora podemos chamar tanto o REPL quanto o compilador a partir de qualquer diretório já que os alias foram devidamente criados e adicionados ao PATH.

Primeiro Hello World com Vim

Agora que temos todo o ambiente instalado (o que na minha opinião é um dos primeiros grandes obstáculos no aprendizado de uma nova linguagem) podemos fazer nosso primeiro Hello World e gerar uma DLL .NET com F#!

Primeiro, vamos definir um diretório de trabalho onde vamos colocar todos nossos projetos. Eu costumo usar um diretório chamado Workspace dentro do meu profile:

cd ~
mkdir Workspace
cd Workspace
mkdir HelloWorldFSharp
cd HelloWorldFSharp

Criado o diretório, criamos também nosso primeiro arquivo com código fonte FSharp utilizando o Vim [4]:

vim HelloWorldFSharp.fs

Isso cria um arquivo chamado HelloWorldFSharp.fs (assumindo que um não exista ou abre para edição caso ele exista) e o abre no nosso editor de texto funcionando dentro de um terminal shell, que pra um usuário Windows (que não tenha usado o Edit do DOS) é algo geralmente desconhecido.

O Vim (como o Vi) oferece basicamente dois modos de trabalho: modo de comando e edição/inserção de texto. Quando abrimos um arquivo, por padrão temos o modo de comando onde o texto digitado não é o que vai para o arquivo, mas sim interpretado como um comando (a seguir).

Para entrar no modo de edição de texto digitamos i ou apertamos a tecla insert do teclado. Note que o texto –INSERT– irá aparecer no canto esquerdo inferior da tela indicando que agora estamos no modo de inserção de texto. Esta área é destinada aos comandos e mensagens do editor.

Estando no modo de edição vamos escrever nosso Hello World!

#light 

printfn "Hello World!"

Com “todo” nosso código completo vamos sair do modo de edição (e voltar ao modo comando) apertando ESC. Para salvar e sair digitamos o comando :wq (write and quit) e enter retornando ao terminal.

Pra compilar nosso código fonte e gerar o primeiro .exe no Linux:

fsharpc HelloWorldFSharp.fs

Obtendo a resposta:

Microsoft (R) F# 2.0 Compiler build 2.0.0.0
Copyright (c) Microsoft Corporation. All Rights Reserved.
tucaz@tucaz-nb:~/Workspace/HelloWorldFSharp$ ls
HelloWorldFSharp.exe  HelloWorldFSharp.fs
tucaz@tucaz-nb:~/Workspace/HelloWorldFSharp$ 

E por último, vamos executar nosso primeiro programa .NET em Linux:

mono HelloWorldFSharp.exe
Hello World!

Fim!

Neste post vimos como instalar Mono/F# no Linux e como criar nosso primeiro programa Hello World em F# utilizando o Vim. No próximo, quero começar a falar mais a respeito de F# e Vim e deixar para trás questões de ambiente.

Até lá!

[1] – Estou utilizando Ubuntu 10.10 AMD64 rodando em um notebook Core i7 (2.66ghz) com 6gb de memória RAM sendo que 2gb ficam exclusivos para VM rodando no Virtual Box. A performance é ótima!

[2] – Menu Principal –> Applications –> Ubuntu Software Center

[3] – Alguma outra sugestão?

[4] – Se o Vim não estiver instalado, basta executar “sudo apt-get install vim” para instalá-lo

• Primeira aula do curso – As demais podem ser encontradas nos vídeos relacionados
• Outros Cursos de Berkeley – Canal da universidade no YouTube com outras diversas aulas
• Vídeos e WebCasts no site oficial da Faculdade – O primeiro link contém os vídeos disponibilizados no YouTube. No entanto, a faculdade também disponibiliza em seu site os mesmos vídeos além de outros da disciplina de ciências da computação.

Depois da reunião oficialmente terminada fomos almoçar e como acabamos entrando no assunto de gestão de projetos comentei um pouquinho a respeito de gestão democrática e prometi deixar alguns links disponíveis:

• Palestra do Akita que foi uma das minhas maiores motivações sobre esse assunto
• Palestra do Ricardo Semler no MIT – Essa é a palestra que o Akita cita como referência
• Lvros de Autoria do Ricardo Semler no Amazon e no Submarino
• Manager Without Managers – Paper da Harvard Business Review também de Autoria do Ricardo Semler sobre o assunto
• Palestra do Akita @ RailsSummit 2009 – Essa é pra quem quiser viajar mais e conhecer as entradas que levam ao assunto de maneira mais profunda