This week, I’m attending the Java Posse Roundup to learn about the interesting things happening on the JVM, meet smart people, and hopefully write some Scala and Clojure code. One of the more surprising emails that I got after registering for the conference came from Dick Wall who asked if I could take an afternoon during the conference to hack some F# with him. Dick prefers to run Ubuntu, and I have wanted to revisit F# on Ubuntu ever since I played around with it a few months back, so I set about installing F# and getting it to run with Monodevelop in Ubuntu.
Below is the process that I used to get everything working on my machine. I don’t claim that this is the best way to do things or that it will even work for anyone else. However, I didn’t find much up to date documentation on the web about running F# on Ubuntu, so hopefully this useful to others. I’ll do my best to keep this up to date, so feel free to post comments on your experiences.
Unlike most installs on Ubuntu, mono is tricky. For various reasons, the mono packages in the Ubuntu repositories are significantly out of date, so you will have to build from source to get even semi-recent updates. I decided that I did not want to overwrite the mono installation that ships with Ubuntu, so these instructions will set you up with a parallel mono installation in /opt/mono.
Before you get started, you’ll need to make sure a few prerequisites are installed. You probably already have most of these if you’re a dev.
sudo apt-get install git build-essential autoconf libtool automake
Next, create (or make sure you have permission to access) /opt/src and /opt/mono since that’s where you’ll be putting all of the fresh mono bits.cd ~ mkdir src sudo mv ./src /opt mkdir mono sudo mv ./mono /opt
It’s easy to install a parallel mono environment once you know what you’re doing. First, you’ll need a couple of dependencies.sudo apt-get install bison gettext
Next, download the mono source. I chose to install mono 2.10 (which was just released at the time of this writing), but you can install whatever version you’d like by modifying the git commands below.cd /opt/src git clone git://github.com/mono/mono mono cd mono git branch mono-2-10 remotes/origin/mono-2-10 git checkout mono-2-10
Now build and install mono. Note: don’t forget the –prefix option since that’s how you avoid overwriting the default mono installation../autogen.sh --prefix=/opt/mono make make install
Setup a Parallel mono Environment
Now that your parallel instance of mono is installed in /opt/mono, you need a way to tell your bash environment to use it instead of Ubuntu’s default mono when you’re developing. You can do that with a short bash script as described on the parallel mono page.
You can create the script anywhere. I put mine in my home foldervim ~/mono-dev-env
Add the following lines to your script to configure the parallel mono environment.#!/bin/bash MONO_PREFIX=/opt/mono GNOME_PREFIX=/usr export DYLD_LIBRARY_FALLBACK_PATH=$MONO_PREFIX/lib:$DYLD_LIBRARY_FALLBACK_PATH export LD_LIBRARY_PATH=$MONO_PREFIX/lib:$LD_LIBRARY_PATH export C_INCLUDE_PATH=$MONO_PREFIX/include:$GNOME_PREFIX/include export ACLOCAL_PATH=$MONO_PREFIX/share/aclocal export PKG_CONFIG_PATH=$MONO_PREFIX/lib/pkgconfig:$GNOME_PREFIX/lib/pkgconfig export PATH=$MONO_PREFIX/bin:$PATH
Now tell bash to use your new environment.source ~/mono-dev-env
You can test that everything is working by running mono -V. Note that if you close your terminal window at any point during the rest of the install, you will have to source the mono-dev-env script again.$ mono -V Mono JIT compiler version 2.10 (mono-2-10/1630b8e Thu Feb 10 18:40:28 EST 2011) Copyright (C) 2002-2011 Novell, Inc and Contributors. www.mono-project.com TLS: __thread SIGSEGV: altstack Notifications: epoll Architecture: x86 Disabled: none Misc: softdebug LLVM: supported, not enabled. GC: Included Boehm (with typed GC and Parallel Mark)
There are a couple of ways to get F# running under mono, but I chose to also build F# from source. A mono-friendly version of the F# source lives on github. Since you will use F# Interactive, you’ll also want to grab libgdiplus, which F# Interactive requires to run properly.sudo apt-get install libgdiplus
With that out of the way, download, build, and install F# from github. Again, don’t forget the –prefix option. Now is a good time to grab a drink since F# can take a while to build.cd /opt/src git clone git://github.com/fsharp/fsharp cd fsharp autoreconf ./configure --prefix=/opt/mono make make install
When you’re done, you can run the following to make sure everything went well.fsc Microsoft (R) F# 2.0 Compiler build (private) Copyright (c) 2002-2010 Microsoft Corporation. All Rights Reserved. error FS0207: No inputs specified
Note that you can also run F# interactive at this point, too.fsi Microsoft (R) F# 2.0 Interactive build (private) Copyright (c) 2002-2010 Microsoft Corporation. All Rights Reserved. For help type #help;; > exit 0;;
Right now you already have a full blown F# development environment at your fingertips, so you could stop at this point. I prefer to have monodvelop since I find that having mouse-over type information is very helpful when writing F#.
Install monodevelop’s Dependencies
Before you can install monodevelop, you’ll need to grab a few of dependencies, but those dependencies have a few dependencies of their own. Fortunately, you can get all of those from the Ubuntu repositories.sudo apt-get install libgtk2.0-dev libgconf2-dev libglade2-dev libgnomecanvas2-dev libgnomeui-dev
Now you’re ready to install gtk-sharp, the first monodevelop dependency. Check out and build the most recent release of gtk-sharp (which at the time of this writing is 2-12).cd /opt/src git clone git://github.com/mono/gtk-sharp gtk-sharp cd gtk-sharp git branch gtk-sharp-2-12-branch remotes/origin/gtk-sharp-2-12-branch git checkout gtk-sharp-2-12-branch ./bootstrap-2.12 --prefix=/opt/mono make make install
Next up is mono-addins.cd /opt/src git clone git://github.com/mono/mono-addins.git mono-addins cd mono-addins ./autogen.sh --prefix=/opt/mono make make install
Finally, you’ll also need gnome-sharp.cd /opt/src git clone git://github.com/mono/gnome-sharp cd gnome-sharp ./bootstrap-2.24 --prefix=/opt/mono make make install
With the dependencies out of the way, you’re clear to install monodevelop. I got version 2.4 of monodevelop since the F# plugin does not work with the latest builds of monodevelop at the time of writing.cd /opt/src git clone git://github.com/mono/monodevelop cd monodevelop git branch 2.4 remotes/origin/2.4 git checkout 2.4 ./configure --prefix=/opt/mono --profile=core make make install
The fsharpbindings project is a plugin that makes adds support for F# to monodevelop. I had trouble getting the latest source working with a parallel mono 2.10 environment on Ubuntu, but I was able to fix the problems with my own branch of the plugin. I’ve put in a pull request, but for the time being, pull from my fork. I’ll update this post once the main fsharpbindings project works with Ubuntu and mono 2.10.cd /opt/src git clone git://github.com/ChrisMarinos/fsharpbinding.git cd fsharpbinding/ ./configure.sh make make install
One Last Bit of Setup
You’re almost there. One last bit of setup is required since the current version of fsharpbindings uses different names for the F# compiler and F# Interactive executables. Create symlinks to get the bindings to work.cd /opt/mono/bin ln -s ./fsi ./fsharpi ln -s ./fsc ./fsharpc
Try it Out!
If everything went according to plan (yeah, right), you should have a full blown F# IDE. Test it out!
Note: When testing the install, I received several weird errors the first time I created a F# project in monodevelop. Monodevelop segfaulted once and also complained about not being able to find “System.Array”. I’m not sure why these errors occur, but simply restarting monodevelop fixed them for me. I’ll update if and when I figure out more.cd ~ monodevelop
You should be able to try out F# by running code in the F# interactive window similar to the one in Visual Studio.
You can also create a console application.
I hope you found the above install process useful, but feel free to leave comments or otherwise contact me if you find problems. F# on mono has come a long way since I last played around with it, and I’m looking forward to watching (and helping) things progress more in the future.
Special thanks to Jay Wren for helping me put this together!