Paolo Donadeo — LifeLOG/Computer programming

Installing OPAM 1.1.1 on a CentOS 6.5

p.donadeo@gmail.com (Paolo Donadeo) — Wed, 21 May 2014 23:00:00 +0000

I'm in this situation: I need to compile an OCaml program on a CentOS 6.5 server. This is actually quite problematic, because CentOS 6.5 provide out of the box a very old OCaml 3.11.2, released by INRIA in January 2010, more than four years ago.

No problem, OPAM come to the rescue! No. The OPAM team doesn't provide a binary executable compatible with the (actually very old) system libraries present in CentOS.

Ok, step back: OPAM can be compiled from sources (instructions here) so it's just a matter of minutes. Again: nope. To compile OPAM you need at least OCaml 3.12.1, while in CentOS we have only 3.11.2.

Step back: first compile and install OCaml from sources. This time I say no, because the whole point of OPAM is to get an up and running OCaml environment in a few minutes, which is actually true in most cases.

I decide to install OCaml using GODI, the “old” OCaml source distribution, the one everybody used before OPAM was born. So the fastest steps to have an OPAM and OCaml environment on a CentOS server are:

download and install GODI;
clone the OPAM repository, compile and install it; it will find a “system” compiler provided by GODI;
$ opam switch 4.01.0 will recompile a new environment;
$ opam switch remove system to delete the “system” environment;
$ rm -Rf ~/godi.

No root access is required in this process, I usually install OPAM in ~/opam, and GODI in ~/godi.

There is an irony in all this story: GODI has been the OCaml source distribution for years, and the coming of OPAM, which is actually newer and has some important features missing in GODI, has produced many frictions in the OCaml community, that in the end caused the shut down of GODI.

The moral part here is: embrace the new things, but don't be too impatient in throwing out the window the precious work that, in the end, still works.

In any case, I want to thank both Gerd Stolpmann (author of GODI) and the OPAM team: they gave to the OCaml community a mature, industrial grade, set of tools to use OCaml.

First release of OCaml binding of Lua library

p.donadeo@gmail.com (Paolo Donadeo) — Sat, 01 Sep 2012 14:06:00 +0000

I'm happy to announce the first release of ocaml-lua, the OCaml binding of the Lua library. With ocaml-lua you can embed a Lua interpreter in an OCaml program in a few lines of code, and use Lua for configuration or customization purposes.

Here are some references:

The homepage of the project is hosted on OCaml Forge;
The complete library reference (ocamldoc generated) is here;
Source tarballs are on the download page on OCaml Forge;
The official GIT repository is here;
Bug reports and feature requests are on my page on GitHub.

I hope it could be useful.

Debugging memory in OCaml: any advice?

p.donadeo@gmail.com (Paolo Donadeo) — Mon, 27 Feb 2012 23:37:00 +0000

A server I just deployed (written in OCaml, of course) seems to eat RAM at breakfast. This is the chart of the RSS field of "ps" in the past 24h (click to enlarge). The program starts with almost 6 Mb and is now reaching 40 Mb, in a linear trend that has nothing good to say.

Any advice on how to debug the memory consumption?

Thanks Mr. Ritchie

p.donadeo@gmail.com (Paolo Donadeo) — Thu, 13 Oct 2011 21:46:52 +0000

Today Unix, or some other operating system deeply inspired by Unix, is pervasive: servers, embedded devices (notably Android, but it's only one) and the “revolutionary” Mac OSX is itself an incarnation of the ideas and works of Dennis Ritchie.

Dennis Ritchie worked on Unix more than 40 years ago, and my questions is: what will we use in forty years? Probably something Dennis Ritchie was working some months ago.

Thanks Mr. Ritchie.

Words of wisdom…

p.donadeo@gmail.com (Paolo Donadeo) — Tue, 27 Sep 2011 17:00:00 +0000

…from Edsger Dijkstra: “Program testing can be used to show the presence of bugs, but never to show their absence!”

Installing OCaml Batteries

p.donadeo@gmail.com (Paolo Donadeo) — Mon, 13 Dec 2010 22:55:00 +0000

In this post I want to help OCaml newcomers to install Batteries. The task is trivial under Linux, while it's a bit tricky under Windows, because OCaml still lacks a self-contained Windows installer.

My assumption is that the reader is a coder, so I will not explain everything… Let's start with the easy part: Linux.

Linux

The installation of OCaml + Batteries under a Debian/Ubuntu system couldn't be easier, thanks the the hard work of the Debian OCaml Task Force. So open a terminal and type:

$ sudo aptitude install ocaml-batteries-included

That's all for Debian/Ubuntu. I don't know how Fedora works, but I think it's easy to install Batteries using YUM, something like:

$ yum install ocaml-batteries-included

If a RPM package for Batteries wasn't available, you could still install OCaml, Camomile (the Unicode library), and compile Batteries from sources, as described below for the Windows OS.

Windows

As said, this OS still lacks a self contained installer which is in progress, at least for installing OCaml. Since many OCaml versions are available for Windows, with different pros and cons, I had to decide which one to use, and I decided to follow the simplest path to reach the goal of installing all the stuff we need. The Cygwin port is by far the simplest way.

Download Cygwin setup and double click the executable. In Windows Vista/7 (I made my test on a Windows 7 64bit box) you will be required to allow the program to be run a couple of times, as usual ;-) …
when the list of available packages appears, select: each and every package containing "caml" (see the screenshot below), and also make, m4, libncurses-devel, git, wget and rlwrap;
open the Cygwin shell;

download the Findlib library, version 1.2.6:

$ wget https://download.camlcity.org/download/findlib-1.2.6.tar.gz

unpack, compile and install Findlib:

$ tar -xpzf findlib-1.2.6.tar.gz
$ cd findlib-1.2.6/
$ ./configure
$ make
$ make install

download, unpack, compile and install Camomile 0.8.1:

$ wget https://prdownloads.sourceforge.net/camomile/camomile-0.8.1.tar.bz2
$ tar -xpjf camomile-0.8.1.tar.bz2
$ cd camomile-0.8.1/
$ ./configure
$ make
$ make install

the last step is to download compile and install Batteries itself. I wasn't able to compile the latest stable release (1.2.2), for an obscure preprocessor error, but using the latest GIT branch everything went smoothly. So here are the steps:
```
$ git clone git://github.com/ocaml-batteries-team/batteries-included.git
$ cd batteries-included/
$ make camomile82
$ make all doc
$ make install install-doc
```

Testing the installation

Before starting to play with the library and the toplevel (the OCaml REPL is called toplevel) let's put into action a couple of helpers.

The OCaml toplevel doesn't support readline. To get this feature back we add an alias to .bashrc. This works in both Linux and Windows:
```
alias ocaml='rlwrap -H /home/paolo/.ocaml_history -D 2 -i -s 10000 ocaml'
```
restart the terminal or load another bash;

we need to load Batteries in the toplevel. This is not strictly necessary, but it helps a lot and the Batteries ASCII logo is wonderful :-). All we need is to create a file named .ocamlinit in the home directory. Open your favorite editor and put this phrases in ~/.ocamlinit:

let interactive = !Sys.interactive;;
Sys.interactive := false;; (*Pretend to be in non-interactive mode*)
#use "topfind";;
Sys.interactive := interactive;; (*Return to regular interactive mode*)

Toploop.use_silently 
             Format.err_formatter (Filename.concat (Findlib.package_directory 
             "batteries") "battop.ml");;

If everything went well you can now type ocaml and something like this should appear:

$ ocaml
        Objective Caml version 3.11.2

      _________________________
    [| +   | |   Batteries   - |
     |_____|_|_________________|
      _________________________
     | -  Type '#help;;' | | + |]
     |___________________|_|___|


Loading syntax extensions...
	Camlp4 Parsing version 3.11.2

Conclusions

This (rather boring) post has been devoted to the installation details of Batteries under Windows, where it presents some difficulties for newbies. Next time we will start on exploring the library with simple examples to exploit its strength.

Pearls of OCaml Batteries (1)

p.donadeo@gmail.com (Paolo Donadeo) — Sun, 05 Dec 2010 15:15:00 +0000

OCaml is known to be a powerful functional programming language, but one of its presumed weakness is a relatively poor standard library.

By accident, I'm one of the few people on the planet considering this very clean and virtually bug free library a feature and not a bug, but this is only an opinion.

The standard library contains everything you need to build applications and other libraries, but it's essential, forget something like the Python standard library and things like “sending an email in one line of code”. Instead, think of the C standard library (plus some important data structures missing in the libc).

More than two years ago the OCaml community decided to start the development of a library containing all the conveniences that are missing in the standard library. The project is OCaml Batteries Included and I'd like to introduce the reader with a series of posts, aimed to cast a light on various aspects of the library, without pretending to be an exhaustive tutorial.

The posts will be targeted at novice OCaml programmers because I think that an experienced OCaml hacker already uses "Batteries" or, in any case, he understand the library API and doesn't need help from this blog.

Before starting with the (boring) installation details, I want to give you a taste of Batteries, to show how a simple task could be written in a more natural way using Batteries modules, in comparison with a vanilla implementation. Let's take this simple task: we want to read a file by lines and print on the terminal only those lines containing a particular substring.

A simple and actually working solution is proposed by the PLEAC-Objective CAML project, it's the very first example of the file access section. Here is the proposed code:

let () =
  let in_channel = open_in "/usr/local/widgets/data" in
  try
    while true do
      let line = input_line in_channel in
      try
        ignore (Str.search_forward (Str.regexp_string "blue") line 0);
        print_endline line
      with Not_found -> ()
    done
  with End_of_file ->
    close_in in_channel

Now let's rephrase using Batteries:

Enum.iter
  (fun l ->
    if BatString.exists l "blue"
    then print_endline l)
  (open_in "/usr/local/widgets/data" |> BatIO.lines_of)

The result is the same, but the code is much cleaner and far more idiomatic for a functional language.

Next time we will see how to install OCaml and Batteries, under Linux of course, but hopefully even under Windows.

Bravo!

p.donadeo@gmail.com (Paolo Donadeo) — Wed, 01 Dec 2010 20:55:33 +0000

Playing with the Google Buzz API I accidentally deleted all of my posts.

Bravo Paolo!

Smart programmers

p.donadeo@gmail.com (Paolo Donadeo) — Tue, 30 Nov 2010 22:00:00 +0000

Do you remember the old article from Paul Graham about the comparison between Python and Java? It's entitled “Beating the averages” and despite the fact that it was written in 2003, it's still relevant.

Why? Try this, and you will be enlightened.

Thanks to Birdack for this link!

(Local copy here for posterity.)

Incubo PHP

p.donadeo@gmail.com (Paolo Donadeo) — Thu, 25 Nov 2010 20:10:00 +0000

Sto facendo la manutenzione di un vecchio sito che avevamo scritto in PHP.

Avevo pessimi ricordi di PHP, ma non mi ricordavo più quanto fosse un incubo programmare in questo, chiamiamolo così, linguaggio.

Disgustoso!