OCaml News

Jane St's Async library

2011-11-08T09:56:00.000-08:00

The good folks at Jane St Capital have kindly released another of their OCaml libraries as open source software. This is the Async library and it is an alternative to the traditional LWT library for asynchronous programming (including IO) in OCaml.

James Woodyatt's Oni library (including lots of data structures)

2011-07-10T10:57:00.000-07:00

James Woodyatt has published his Oni library of miscellaneous OCaml goodness that includes lots of interesting data structures.

Highlighted features include:

- Functional streams and stream processors (extended).
- Functional bootstrapped skew-binomial heap.
- Functional red-black binary tree (associative array).
- Functional sets based on red-black binary tree.
- Functional real-time catenable deque.
- Functional LL(x) parsing using state-exception monad.
- Functional lazy deterministic finite automaton (DFA).
- Functional lexical analyzer (using lazy DFA and monadic parser).
- Functional substring list manipulation (message buffer chains).
- Gregorian calendar date manipulation.
- Standard time manipulation.
- System time in Temps Atomique International (TAI).
- Unicode transcoding.
- Universal resource identifier (URI) manipulation.
- Extended socket interface (supports more options, and UDP w/multicast).
- I/O event multiplexing (with Unix.select).
- Functional XML stream parsing and generation - Functional MIME stream parsing and generation

More OCaml jobs than ever before

2011-03-05T09:03:00.000-08:00

The IT Jobs Watch website shows that the number of job advertisements citing OCaml is at its highest level ever:

OCaml on the iPad

2010-11-21T08:16:00.000-08:00

The OCaml Example app in the iPad store lets you write and run OCaml programs on your iPad:

Data structures: Heaps

2010-08-06T06:57:00.000-07:00

The OCaml Journal just published an article about data structures:

"A min-heap is a tree-based data structure that satisfies the constraint that the children at any given branch are always larger than their parent and, consequently, the minimum element is at the root. Heaps are most notable as an efficient way to implement priority queues which, in turn, underpin a variety of algorithms including some seen in previous OCaml Journal articles. This article examines skew heaps, leftist heaps, pairing heaps and binomial heaps. Higher-order modules are used to create reusable implementations..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml 3.12 released!

2010-08-02T15:35:00.000-07:00

A new version of the OCaml distribution was released today, OCaml 3.12.0. This release includes many exciting developments to the language as well as a multitude of other improvements:

Improved record patterns.
Explicit method override.
Local open.
Direct polymorphic recursion via type annotations.
First-class modules.
Named types as parameters to functions.

Rigid body dynamics

2010-07-30T19:01:00.000-07:00

The OCaml Journal just published an article about game physics:

"A common technique to simulate the dynamics of objects is to model them as interacting rigid components. This article describes the design and implementation of a simple OCaml program that uses rigid body dynamics to simulate balls bouncing around in 2D, using OpenGL for 2D visualization..."

To read this article and more, subscribe to The OCaml Journal today!

The diff tool

2010-07-08T21:15:00.000-07:00

The OCaml Journal just published an article about sequence algorithms:

"The unix program diff identifies differences between text files, line by line. This tool is most useful for comparing two versions of a program. This article develops a simple implementation of the diff tool based upon the longest common subsequence (LCS) algorithm and examines the output from it..."

To read this article and more, subscribe to The OCaml Journal today!

Tuning the OCaml memory allocator for large data processing jobs

2010-06-25T18:11:00.000-07:00

Michael Ekstrand has published an interesting blog article about tuning the OCaml garbage collector for large-scale computations.

Quicksort

2010-06-25T18:08:00.000-07:00

The OCaml Journal just published an article about sorting:

"The quicksort algorithm was invented by Tony Hoare in 1960 and remains one of the most celebrated algorithms and is still of great practical value. Implementing some of the many variations of the quicksort algorithm serves as an excellent introduction to programming in OCaml..."

To read this article and more, subscribe to The OCaml Journal today!

Visualizing the 2D Fourier Transform

2010-06-14T14:58:00.000-07:00

The OCaml Journal just published an article about the visualization of numerical methods:

"The Fourier transform is one of the most important numerical methods and underpins most forms of spectral analysis. This article describes a simple image compression technique that uses the 2D Fast Fourier Transform (FFT) to remove the high-frequency components of an image, visualizing the result using GTK..."

To read this article and more, subscribe to The OCaml Journal today!

ICFP draft from Citrix

2010-06-08T08:11:00.000-07:00

Citrix have published a draft of a report due to appear at ICFP describing their use of OCaml in industry, specifically the Management Tools Team (MTT) responsible for the 130kLOC of OCaml code that runs XenServer. The free and commercial editions of the product are deployed in over 40,000 companies worldwide.

Interestingly, none of the perceived risks associated with using a non-mainstream programming language turned out to be a problem. Good OCaml programmers were in abundance. XenSource was acquired by Citrix without any concern about the use of OCaml. Other teams within the company had no problem contributing to the OCaml code base. The OCaml tool chain turned out to be mature enough to support the project.

OCaml in industry 2007-2010

2010-06-06T08:41:00.000-07:00

Looking back, there have been a number of significant advances in the use of OCaml in industry over the past few years:

The number of developers contributing to the OCaml code base at XenSource grew to 18 in November 2008. XenSource was subsequently sold to Citrix for US$500,000,000.
The number of full-time OCaml developers at Jane St grew beyond 30 in January 2009.
MIT startup Cilk Arts sold their Cilk++ tool chain, which is partly written in OCaml, to Intel in August 2009.
Intel, Jane St, Citrix, CEA, OCamlCore, SimCorp and MLState paid to join the CAML Consortium (now 11 members in total).
Coherent Graphics shipped their first product, written in OCaml.
The world's largest people search engine, Wink, was launched (and it is written almost entirely in OCaml).
MLState released their first product, Opa, which is written entirely in OCaml (Nov 2009).

And, of course, Microsoft released the world's first mainstream functional programming language F# in April 2010 and it is a close relative of OCaml. That had the knock-on effect of boosting interest in OCaml considerably.

Sliding Median

2010-05-23T20:17:00.000-07:00

The OCaml Journal just published an article about sliding window algorithms:

"Sliding window algorithms are a class of algorithms that treat streams of data by computing a statistic across a window for each position of the window within the data stream. Moving averages are sliding window algorithms that compute an average over each window. This article examines the moving median algorithm that tracks the median value in a window as it slides across a stream of data. Several possible solutions are examined and their performance is studied on an example data set..."

To read this article and more, subscribe to The OCaml Journal today!

Artificial Intelligence: Neural Networks

2010-05-13T16:10:00.000-07:00

The OCaml Journal just published an article about artificial intelligence:

"Artificial neural networks are a relatively simple and early form of artificial intelligence modelled directly on the structure of an organic brain. A neural network is composed of many interconnected neurons. Each neuron acts as a simple linear classifier by summing its weighted inputs and firing an output accordingly. The functions involved are essentially ad-hoc but are usually modelled on those of real neurons. This article describes the design and implementation of a neural network that uses an unconventional functional approach to handle vector-matrix operations that allows temporary data structures to be avoided..."

To read this article and more, subscribe to The OCaml Journal today!

Compiler development: part 3

2010-04-24T18:51:00.000-07:00

The OCaml Journal just published an article about HLVM:

"This article continues our series on compiler development using HLVM. An example is provided that breaks the current compiler. The bug is investigated using different techniques and a well-known solution is implemented. The resulting compiler is then tested on a substantially more complicated symbolic computation and is found to obtain the correct result. Moreover, the time taken to perform this symbolic computation using HLVM is found to be very competitive despite the fact that HLVM was not at all designed for this purpose...."

To read this article and more, subscribe to The OCaml Journal today!

OCaml meeting 2010 debriefing

2010-04-24T10:46:00.000-07:00

Members of the OCaml community met with the core developers at this year's OCaml Meeting 2010 on April 16th. Attendance was up to the maximum capacity of 80 people this year! The meeting was funded by the 11 corporate members of the CAML Consortium that now includes MLState as a new addition this year.

Slides and references for the lectures given by Xavier Leroy, Sylvain Le Gall, Stefano Zacchiroli, Julien Robert, Guillaume Von Tokarski, Sylvain Conchon, Jean-Christophe Filliâtre, Fabrice Le Fessant, Gerd Stolpmann, Dario Teixeira, Daniel Bünzli, David Rajchenbach-Teller, Philippe Wang, Jérémie Dimino, William Le Ferrand and Anil Madhavapeddy are available here.

Of particular interest was the keynote speech by Xavier Leroy (read the slides) about the forthcoming OCaml 3.12 release that introduces lots of exciting new features to the OCaml programming language such as first-class modules.

The A* algorithm

2010-04-10T12:39:00.000-07:00

The OCaml Journal just published an article about path finding:

"The A* algorithm is often used for route finding in game AI and is a generalization of Dijkstra's shortest-path algorithm from graph theory. This article describes a simple implementation of the A* algorithm written in OCaml that makes extensive use of the module system including higher-order modules (functors) in order to provide a reusable implementation of this algorithm that is generic over the kinds of graphs that it can handle. Finally, an example application is provided that finds a route around a hill...."

To read this article and more, subscribe to The OCaml Journal today!

Unix systems programming in OCaml

2010-04-08T12:34:00.001-07:00

The English translation of the introductory book Unix systems programming in OCaml by Xavier Leroy and Didier Rémy was just completed and is now freely available on-line.

This book is an excellent complement to our own OCaml for Scientists book.

Compiler development: part 2

2010-03-29T19:25:00.000-07:00

The OCaml Journal just published an article about HLVM:

"This article is the second in a series describing the design and implementation of a complete compiler using the freely-available HLVM project described in previous articles. This article extends the compiler implemented in part 1 of the series with support for variant types and basic pattern matching. This requires changes to the representation of the compiler's input, the lexer, the parser, the compiler and the REPL. The language implemented by the resulting compiler is substantially more expressive than the previous version and allows monomorphic ML-style programs to be compiled and executed..."

To read this article and more, subscribe to The OCaml Journal today!

Word games

2010-03-15T18:03:00.000-07:00

The OCaml Journal just published an article about string-based algorithms:

"String manipulation is a common task in programming and, in particular, when scripting. Solving word puzzles is an excellent way to learn how these kinds of problems can be approached. This article uses the example of word games to develop a series of program that manipulate strings using different techniques in OCaml, including sorting and searching..."

To read this article and more, subscribe to The OCaml Journal today!

Implementing Hindley-Milner type inference

2010-03-06T19:50:00.000-08:00

The OCaml Journal just published an article about type checking:

"This article walks through the design and implementation of the Hindley-Milner type inference algorithm written in OCaml. This algorithm is the foundation of type inference most modern functional programming languages including OCaml. The algorithm acts upon expressions and types using type scheme, substitutions and type environments to infer the type of a given expression..."

To read this article and more, subscribe to The OCaml Journal today!

Recursive descent parsing with OCaml's streams

2010-02-07T20:18:00.000-08:00

The OCaml distribution includes a mutable stream type that allows sequences to be dissected efficiently. The camlp4 syntax for OCaml includes support for pattern matching over streams.

The following example uses the camlp4 stream-parsing syntax extension to implement a recursive descent parser for a simple calculator:

let rec factor = parser
  | [< ''('; e = expr; '')' >] -> e
  | [< 'c >] -> int_of_string (String.make 1 c)

and term = parser
  | [< e1 = factor; e = term_aux e1 >] -> e
and term_aux e1 = parser
  | [< ''*'; e2 = term >] -> e1 * e2
  | [< ''/'; e2 = term >] -> e1 / e2
  | [< >] -> e1

and expr = parser
  | [< e1 = term; e = expr_aux e1 >] -> e
and expr_aux e1 = parser
  | [< ''+'; e2 = expr >] -> e1 + e2
  | [< ''-'; e2 = expr >] -> e1 - e2
  | [< >] -> e1

let rec statement = parser
  | [< e = expr; '';'; ''.'; stream >] ->
      Printf.printf "= %d\n%!" e;
      statement stream

let rec read() = match input_char stdin with
  | ' ' | '\t' | '\n' -> [< read() >]
  | c -> [< 'c; read() >]

let () = statement (read())

This program may be compiled and run as follows:

$ ocamlc -g -dtypes -pp camlp4o parser.ml -o parser
$ ./parser
1+2+3;.
= 6
1+2*3;.
= 7
1+2*3+4;.
= 11

Force-based network visualization

2010-02-07T20:14:00.000-08:00

The OCaml Journal just published an article about the interactive visualization of networks:

"Visualizing a graph or network of interconnected nodes is a fascinating and important challenge with a wide variety of practical applications. This article looks at a simple but effective force-based approach to the visualization of networks and uses OpenGL to display the results in real-time as they emerge and GTK+ to provide interactive user control. The result is a compelling interactive animation of the layout algorithm as it progresses..."

To read this article and more, subscribe to The OCaml Journal today!

MLState release their first product: OPA

2010-01-30T11:09:00.000-08:00

The One Pot Application (OPA) from MLState is a complete development platform for web applications and services:

Development in OPA requires no plumbing. Applications developed with OPA are automatically checked for safety and security before they are executed. Applications developed with OPA are automatically (and provably) immune to cross-site scripting, to SQL injections and to most existing forms of attacks. And OPA provides language support for storage, communication between client and server (Ajax and Comet), concurrency, distribution, mobility, etc.

Read more from MLState or watch the video.

High-performance parallel programming with HLVM

2010-01-26T11:00:00.000-08:00

The OCaml Journal just published an article about HLVM:

"This article describes how a global adjustment of the calling convention brings the performance of the multicore-capable HLVM within 17% of its original single-threaded performance. A simple parallelization of the new ray tracer benchmark is then described that obtains a substantial 6.3× speedup on 8 cores, demonstrating the potential of the new design for high-performance parallel computing..."

To read this article and more, subscribe to The OCaml Journal today!

More OCaml jobs

2010-01-26T10:29:00.000-08:00

The world's second largest OCaml employer (Citrix) have announced that they are hiring more OCaml programmers in the UK to maintain and develop their code base that has grown to hundreds of thousands of lines of OCaml code.

Martin Jambon also announced recently that MyLife (formerly Wink) are also looking for an OCaml developer.

Low-level optimization tips and tricks: part 4

2010-01-20T06:08:00.000-08:00

The OCaml Journal just published an article about optimization:

"The OCaml programming language is unusually well suited to high-performance computing among functional programming languages because it provides a highly efficient code generator with a performant run-time and garbage collector. This makes it feasible to write high performance programs entirely in OCaml without having to drop to lower-level languages like C and Fortran for performance-critical sections of code. This article focuses on the internal representation of data structures. An overview of OCaml's data representation strategy is given. Tools to examine values in the heap, including OCaml's own Obj module, are described. Then several approaches to optimization that are related to data representations are covered, including closures, polymorphic variants, bounds checking, functors and integer arithmetic..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml Batteries included 1.0.0 released

2010-01-20T05:34:00.000-08:00

The Batteries Included project that has intended to provide an extensive defacto-standard library for OCaml for over two years has finally reached version 1!

This library includes a wealth of indispensable features with extensive documentation covering topics such as:

Mutable and immutable data structures (reusable AVL trees, bit sets, string buffers, extensible arrays, lazy lists, polymorphic sets and maps, ropes).
Mathematics (extensive complex number support).
Abstractions (enumerations).
File and IO related helper functions.
Pretty printers and functional unparsers.
Memory management helper functions.
Consistent interfaces/signatures.
Unicode support.

Download your copy here!

Garbage collecting multithreaded programs

2010-01-03T09:42:00.000-08:00

The OCaml Journal just published an article about HLVM:

"Executing threads in parallel is the cornerstone of efficient parallel programming on shared-memory machines including today's multicores. This article describes how a simple stop-the-world garbage collector can be implemented in HLVM, allowing code generated from an OCaml program to leverage multicores easily..."

To read this article and more, subscribe to The OCaml Journal today!

Parsing and visualizing binary Geographic Information System data

2010-01-03T09:37:00.000-08:00

The OCaml Journal just published an article about parsing binary data:

"Detailed vector descriptions of worldwide geographical data are freely available in the Shapefile format. This article describes how polygonal data can be parsed from the binary Shapefile format and visualized using OpenGL and GLU easily and efficiently with OCaml. The result is a simple program that can be used as the basis for a wide variety of Geographic Information System (GIS) applications from cartography to climatology..."

To read this article and more, subscribe to The OCaml Journal today!

Formally verifying Intel's floating-point arithmetic using OCaml

2009-12-21T18:42:00.000-08:00

When a bug in floating point division on the Pentium processor was discovered, Intel had to set aside $475,000,000 to cover the cost of replacing the faulty hardware. To minimize the risk of this happening again, Intel now formally verify their floating point hardware using theorem-proving software written in OCaml.

John Harrison of Intel has kindly made the fascinating slides from his lecture about Intel's use of OCaml freely available.

John has a new book out called the Handbook of Practical Logic and Automated Reasoning.

Parallel programming from OCaml using HLVM

2009-11-30T16:16:00.000-08:00

Our HLVM project has hit another milestone with new support for parallel programming using threads.

HLVM threads and mutexes are a thin wrapper over POSIX threads. The mark+sweep garbage collector now uses a stop-the-world algorithm to suspend all mutator threads while a single thread traverses the entire heap marking and then traverses all allocated values reclaiming unmarked values. This is a very simple design and an unoptimized implementation but it already makes it possible to write parallel programs passing shared mutable state between threads by reference from OCaml.

Generating and visualizing 2D mazes

2009-11-27T11:50:00.000-08:00

The OCaml Journal just published an article about mazes:

"Maze generation is a remarkably complex and diverse subject that essentially falls into the category of network or graph theory but is most often seen in the context of games and puzzles. The characteristics that make a maze interesting for humans to try to navigate are subjective and not easily defined and, consequently, the design and implementation of an automatic maze generator is as much an art as it is a science. This article describes the design and implementation of a simple but effective maze generation algorithm including OpenGL-based visualization. The algorithm is elegantly expressed in terms of recursive functions and purely functional data structures..."

To read this article and more, subscribe to The OCaml Journal today!

Logic programming: n-queens and knight's tour problems

2009-11-11T08:20:00.000-08:00

The OCaml Journal just published an article about AI:

"Logic programming is a paradigm often seen in problem solving and AI. This article introduces the subject of logic programming and explains why the OCaml language and implementation are ideally suited to these kinds of applications, using the familiar examples of solving the n-queens problem and finding a knights tour..."

To read this article and more, subscribe to The OCaml Journal today!

LLVM 2.6 support and a new HLVM garbage collector

2009-10-25T09:49:00.000-07:00

The OCaml Journal just published an article about LLVM and HLVM:

"This article describes the changes required to bring HLVM up to date with respect to the new LLVM 2.6 release as well as a new garbage collector design. The previous collector mapped pointers onto their mark state via a hash table. This update uses the more conventional design of placing the mark state in the heap, using a mark-sweep garbage collector to reclaim unreachable values. The new collector is simpler and offers different performance characteristics..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml4Multicore (oc4mc)

2009-10-25T09:46:00.000-07:00

The OCaml Journal just published an article about the new parallel OCaml implementation:

"OCaml4Multicore is a modified OCaml compiler that allows POSIX threads to run in parallel. This is a major development that makes shared-memory parallel programming much easier and also has the potential to make it far more efficient for many important appications. This article introduces the subject of thread-based parallel programming, explains why it is difficult to facilitate in OCaml-like language implementations and examines the performance characteristics of oc4mc..."

To read this article and more, subscribe to The OCaml Journal today!

The Graphics module: Pythagoras Tree

2009-09-24T07:26:00.000-07:00

The OCaml Journal just published an article about the built-in Graphics module:

"The OCaml distribution includes a Graphics module that provides a set of easy-to-use portable drawing primitives ideal for educational purposes and experimentation. This article describes the recursive construction of some digital art built around Pythagoras' triangle. The results are visualized interactively using the Graphics module..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml finally goes multicore

2009-09-24T05:08:00.000-07:00

Philippe Wang made the exciting announcement recently that the first working version of oc4mc, OCaml with a new parallel garbage collector, has been released. This revolutionary development allows threads in OCaml programs to be executed in parallel for the first time, making it possible to leverage multicores efficiently in OCaml programs.

We can confirm that oc4mc is working on one of our 8-core machines and shows excellent speedups for simple multithreaded numerical computations.

The next major developments in this area will doubtless be better libraries for parallel programming in OCaml, the adoption of oc4mc in the major apt repositories used by the majority of Linux programmers and finally the creation of literature describing the design and characteristics of this implementation.

Congratulations to the team (Mathias Bourgoin, Adrien Jonquet, Emmanuel Chailloux, Benjamin Canou and Philippe Wang) for making this happen and thanks to Jane St. Capital for making the project possible!

Stanford Bunny

2009-09-24T04:54:00.000-07:00

The OCaml Journal just published an article about mesh visualization:

"The Stanford bunny is a 3D mesh of triangles commonly used as a benchmark for computer graphics applications. This article presents an 85-line OCaml program that uses OpenGL to render the Stanford bunny in real time: the mesh is represented as a vertex array and an index array. The vertex array is a sequence of 3D vertex coordinates. The index array is a sequence of triples of indices into the vertex array referring to the three vertices of each triangle. Normals are generated independently for each vertex as the sum of the normals of every triangular face sharing each vertex, in order to provide smooth shading..."

To read this article and more, subscribe to The OCaml Journal today!

Traversing networks: the nth-nearest neighbor

2009-09-24T04:53:00.000-07:00

The OCaml Journal just published an article about graph theory:

"Graph theory has a great many practical applications ranging from compiler internals to the study of the structural characteristics of materials. This article describes the design and implementation of a program that finds the nth-nearest neighbors of a given vertex in an infinite graph. This problem is of interest in the context of atomic structures..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml internals

2009-08-24T01:35:00.001-07:00

Richard Jones has written an excellent series of blog posts about the internals of the OCaml implementation:

Dynamic programming: Levenshtein edit distance

2009-08-09T11:00:00.001-07:00

The OCaml Journal just published an article about dynamic programming and memoization:

"Levenshtein distance is a metric used to measure the amount of difference between a pair of sequences in terms of the number of insertions, deletions and substitutions required to get from one sequence to the other. Computing the Levenshtein distance is an interesting problem in dynamic programming with many practical applications including spell checkers and the study of DNA in bioinformatics. This article describes how the basic algorithm may be implemented and then optimized, including the use of both generic and specialized memoization..."

To read this article and more, subscribe to The OCaml Journal today!

Optimizing the Burrows-Wheeler Transform

2009-07-25T07:08:00.000-07:00

The OCaml Journal just published an article about parallelized data compression:

"The Burrows-Wheeler Transform (BWT) is one of the few preconditioners used in data compression and, in particular, is the core of the popular bzip2 compression utility. This article describes a simple 19-line implementation of the BWT in OCaml and progressively optimizes the implementation to use a customized quicksort then distributed fork-based parallelism and finally shared-memory parallelism. On 8 cores, the final optimized implementation is over 65× faster than the original..."

To read this article and more, subscribe to The OCaml Journal today!

QR decomposition: a case study in profiling and optimization

2009-07-10T21:35:00.000-07:00

The OCaml Journal just published an article about high-performance numerical methods:

"The challenge of finding the least squares best fit of a linear sum of functions is a common problem in regression. Linear algebra provides a powerful and general solution by expressing this problem in terms of matrices and then computing the QR decomposition in order to solve the matrix equation. This article describes a remarkably simple implementation of QR decomposition in OCaml and uses it as a case study for profiling and optimization..."

To read this article and more, subscribe to The OCaml Journal today!

HLVM documentation now on-line

2009-06-24T17:18:00.001-07:00

To celebrate HLVM entering the top 10 most downloaded projects on OCamlForge, we have created a new home page for the project that includes a description of the motivation behind the creation of HLVM and a link to the ocamldoc-generated documentation for the HLVM virtual machine and well as references to the growing number of articles about HLVM.

We are also starting a consortium of industrial users to provide financial backing for the HLVM project in order to accelerate its development and we are offering technical support at competitive rates.

Compiler development: part 1

2009-06-23T19:24:00.000-07:00

The OCaml Journal just published an article about compilers:

"This article is the first in a series describing the design and implementation of a complete compiler for a non-trivial language using the freely-available HLVM project described in previous articles. The representation of types, patterns and expressions, the lexer, parser and Read-Evaluate-Print-Loop (REPL) with JIT compilation are described in this article..."

To read this article and more, subscribe to The OCaml Journal today!

New HLVM examples

2009-06-21T14:19:00.001-07:00

The High-Level Virtual Machine (HLVM) project aims to combine the expressiveness of functional programming languages, the performance of C and the interoperability and libraries of an industrial-strength virtual machine. This project was recently updated to include two new example programs built upon HLVM:

A calculator that JIT compiles arithmetic expressions in order to evaluate them, written in only 28 lines of OCaml!
A compiler for a tiny caml-like language that handles unit, char, int, float and tuple types along with some example programs written in only 228 lines of OCaml!

These working examples should help HLVM users. In particular, the design and implementation of the second example, a complete compiler, will be described in the next OCaml Journal article.

Check out HLVM's SVN repository now with:

svn checkout svn://svn.forge.ocamlcore.org/svnroot/hlvm

Visualizing the Singular Value Decomposition

2009-06-08T18:38:00.000-07:00

The OCaml Journal just published an article about the illustration of matrix computations:

"Singular Value Decomposition (SVD) is an important algorithm from linear algebra that decomposes a matrix into the product of three simpler matrices. The resulting decomposition has several applications. This article describes the design and implementation of an OCaml program that computes the SVD of an image and uses it to create a lossy compression algorithm with controllable quality. This involves numerical methods for computing the eigenvalues of real symmetric matrices and interactive visualization of the result as a GTK application using the camlimages library to load images from file..."

To read this article and more, subscribe to The OCaml Journal today!

Pretty printing with the Format module and Camlp4 stream parsers

2009-05-23T06:08:00.000-07:00

The OCaml Journal just published an article about pretty printing and parsing:

"The OCaml programming language has evolved a rich variety of libraries and tools over the past thirteen years. The domain of metaprogramming is particularly well supplied. This article describes the basic design of OCaml's Format module which provides customizable formatting and, in particular, user-extensible pretty printing for the top-level as well as the stream parsers provided by camlp4..."

To read this article and more, subscribe to The OCaml Journal today!

Lempel-Ziv-Welch data compression

2009-05-09T07:14:00.000-07:00

The OCaml Journal just published an article about data compression:

"LZW is a simple and effective dictionary-based data compression algorithm originally published in 1984 and subsequently used in several prominent places including the GIF image format. This article describes simple purely functional implementations of the compression and corresponding decompression algorithms before examining the optimization of these implementations via the selective inclusion of mutable data structures..."

To read this article and more, subscribe to The OCaml Journal today!

Review: The OCaml Journal

2009-04-24T19:49:00.000-07:00

Daniel de Kok has kindly written a review of The OCaml Journal. He says:

"Alp Mestan has written a short review of the OCaml Journal. I can only echo his recommendation. I have just started learning OCaml, and can use as much exposure as possible to a variety of interesting problems and solutions. Last week I subscribed to the OCaml Journal, and that has been a very good decision.

Subscribers have access to the archive of previous articles, which are very diverse, both in subject and level. As a newcomer, I have enjoyed the articles about pattern matching, the OCaml standard library, and object-oriented programming in OCaml. I have started looking into the articles about combinators, parser combinators, and optimization. All articles are written in a clear manner and complemented by fun examples and plenty of code to tinker with. If you enjoy OCaml, and want to learn more by theory and practice, I can wholeheartedly recommend the OCaml Journal."

Great to see another happy customer. Thanks Daniel!

Purely functional data structures: streams, queues and catenable lists

2009-04-24T19:44:00.000-07:00

The OCaml Journal just published an article about the implementation of efficient purely functional data structures using OCaml 3.11 and its new lazy patterns:

"This article is the first in a series describing the design and implementation of some very useful purely functional data structures. Lazy streams, batched and real-time queues and lists with O(1) concatenation are described in detail. In particular, functors are used extensively to provide elegant parameterization over data structures and some of the new features in OCaml 3.11 are used to improve both performance and clarity..."

To read this article and more, subscribe to The OCaml Journal today!

Review: The OCaml Journal

2009-04-09T08:54:00.000-07:00

Alp Mestan has kindly written a review of The OCaml Journal and, in particular, our series of articles about low-level optimization. He says "These articles have really helped me". The full review is available here.

OCaml 3.11 moves into Debian testing!

2009-04-09T08:24:00.000-07:00

The highly-anticipated OCaml 3.11 just made it into the current Debian testing distribution, codename Squeeze. Debian is a famously-robust Linux distribution with a superb packaging system and an army of expert package maintainers. Debian-based distributions such as Ubuntu account for over 70% of all Linux users. So this is excellent news for the tens of thousands of OCaml programmers who rely on Debian packages for their OCaml distribution!

This new version of OCaml includes several important improvements. Perhaps the most notable of which is the new support for lazy patterns that force lazy values only when they are required by the pattern matcher. This makes it easy to dissect lazy data structures such as lazy sequences using pattern matching and, consequently, will spark a marked change in data structure APIs. For example, it is now easy to expose a lazy sequence interface to a set data structure and use that to detect sets that contain exactly three elements. Previously, that would have been done by beginning a fold and terminating when three elements had been visited.

Another important new feature is native-code support for the Dynlink module that handles dynamically-loaded OCaml libraries or plugins.

Thank to everyone involved for making this happen! Needless to say, all of the new features provided by OCaml 3.11 will be covered in detail in The OCaml Journal.

Emergent behaviour: flocking boids

2009-04-05T02:04:00.000-07:00

The OCaml Journal just published an article about emergent behaviour:

"Artificial life became a popular topic in the 1980s. In particular, with the discovery that simple rules defining the behaviour of individuals could give rise to sophisticated behaviour of groups of individuals. This unexpected result was described as "emergent behaviour" and one of the most famous examples was a computer program called "Boids" that used only three simple rules to govern the dynamics of individuals but produced remarkably realistic flocking behaviour of the population as a whole. This article describes an interactive boids simulator with a graphical user interface implemented using GTK+..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml batteries included

2009-04-05T01:53:00.000-07:00

The batteries included project is one of the most exciting developments in the OCaml world today and promises to provide a comprehensive suite of well-documented libraries and language extensions that will be bundled with any compliant OCaml distribution.

The project is apparently nearing its first major release and has even found its way into current Debian-based distros.

The language extensions are one of the most interesting aspects of this project because they augment OCaml with first-class support for a variety of new features. David Rajchenbach-Teller was kind enough to list some of the features related specifically to strings on the caml-list:

Regular OCaml strings.
Strings with capabilities (i.e. strings which, depending on their type, can be read-only/write-only/read-write) -- sometimes faster than regular strings, never slower.
Immutable Unicode ropes.

Given OCaml's recent uptake as a scripting language for concurrent programming, string handling is of growing importance and these language extensions will be a welcome addition!

Building a Virtual Machine with LLVM: part 3

2009-03-22T21:35:00.000-07:00

The OCaml Journal just published an article about the HLVM project:

"This is the third and final article in the series about the design and construction of the high-level virtual machine (HLVM). This article describes the design and implementation of boxed values for sum types and a simple garbage collector. In particular, the difference between the run-time representations of values in OCaml and HLVM is described in detail and the GC implementation described is partially generated at run-time and JIT compiled..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml at Cilk Arts Ltd.

2009-03-19T12:43:00.000-07:00

Cilk is an award-winning language for multithreaded parallel programming based on ANSI C and is the culmination of 15 years of research at MIT in preparation for the shared memory multicore computers that are now ubiquitous. An open source implementation of Cilk is freely available.

We have tried Cilk ourselves and found the solution it provides to be both easy and extremely efficient and it is certainly preferable to cumbersome alternatives like OpenMP. In fact, we were so impressed that we are not only using Cilk to write an experimental parallel garbage collector for our HLVM project but we are also drawing upon the design of Cilk to provide high-level parallel constructs as well.

The group responsible for Cilk founded a spin-off company Cilk Arts Ltd. in 2006 using venture capital. Cilk Arts released their first commercial product, Cilk++, in 2008. The company is now rapidly asserting itself as a major player for shared memory parallel programming.

Interestingly, although the open source implementation of Cilk is written in C, Cilk Arts have been hiring OCaml programmers since 2007 because a "major part" of their code base is written in OCaml.

Low-level optimization tips and tricks: part 3

2009-03-07T21:19:00.000-08:00

The OCaml Journal just published an article about optimization:

"The OCaml programming language is unusually well suited to high-performance computing among functional programming languages because it provides a highly efficient code generator with a performant run-time and garbage collector. This makes it feasible to write high performance programs entirely in OCaml without having to drop to lower-level languages like C and Fortran for performance-critical sections of code. This article gives a case study that covers many of the techniques described so far before describing how the performance of the FFI can be improved and some optimizations that often provide substantial performance improvements in OCaml..."

To read this article and more, subscribe to The OCaml Journal today!

Book review: "The Objective Caml Programming Language" by Tim Rentsch

2009-02-28T06:03:00.000-08:00

Abscissa Press recently published The Objective Caml Programming Language by Tim Rentsch and were kind enough to send us a complimentary copy of the book for review even though we are the creators of the related book OCaml for Scientists.

The Objective Caml Programming Language is a 264-page paperback that covers many features of the OCaml programming language including expressions, variables, functions, pattern matching, tuples, lists, polymorphism, unions, references, loops, records, arrays, strings, exceptions, IO, compilation, debugging, modules, functors, objects, inheritance, polymorphic classes and touches upon some other topics including labeled and optional arguments and laziness.

The core content is derived largely from Jason Hickey's academic course on OCaml at Caltech but also includes 87 pages describing OCaml's object system. The book has been carefully typeset and is a pleasure to read. The style of writing is purely theoretical and presents technical content with many examples, academic exercises and it is mostly accurate. Consequently, this book is ideal for anyone who already has a strong background in computer science and wants to learn the OCaml language.

However, this is not a pragmatic book and no attention is given to programming style, libraries, tools, optimization or other issues that are very important for anyone who wants to use OCaml for general purpose programming.

The Objective CAML programming language by Tim Rentsch is available from Barnes and Noble and Amazon for only £25.

Building a Virtual Machine using LLVM: part 2

2009-02-20T06:45:00.000-08:00

The OCaml Journal just published an article about the LLVM:

"This is the second article in the series about our high-level virtual machine (HLVM) project. This article builds upon the foundations laid in the first article to create a much more practically useful language implementation by adding tail call elimination, first-class structs, a foreign function interface (FFI) and first-class function pointers..."

To read this article and more, subscribe to The OCaml Journal today!

Toy Lisp implementation written in C++ using LLVM

2009-02-19T10:55:00.000-08:00

We recently stumbled upon this toy Lisp implementation. The compiler is written in C++ and uses LLVM for high performance JIT compilation. Although the compiler makes no attempt to be efficient with statically-known types the implementation is still interesting from an OCaml perspective because it includes first-class functions.

Simulating smoke in real-time using fluid dynamics

2009-02-08T03:45:00.000-08:00

The OCaml Journal just published an article about computational fluid dynamics:

"In scientific computing, the task of simulating fluid flow accurately by solving the Navier-Stokes equation is notoriously difficult. However, it is possible to compute numerical approximations quickly enough that fluids dynamics may be simulated in real time. This article describes a simple fluid dynamics simulator that uses OpenGL to visualize the results in real time..."

To read this article and more, subscribe to The OCaml Journal today!

New book: The Objective Caml Programming Language

2009-02-08T01:42:00.000-08:00

Abscissa Press published a new book on OCaml called The Objective Caml Programming Language by Tim Rentsch in September 2008.

Information about this product is sparse: there have been no advertisements, nobody has written a review yet and it is not even clear what subjects the book covers but the description on Amazon implies that this is the first book to cover OCaml's object oriented capabilities in detail.

Building a Virtual Machine using LLVM: part 1

2009-01-25T04:19:00.000-08:00

The OCaml Journal just published an article about compiler writing:

"This article is the first in a series examining the design and construction of a simple high-level virtual machine (HLVM) written in OCaml and building upon LLVM. Despite its simple design, the HLVM offers excellent performance, rich run-time types with reflection, tail calls, accurate garbage collection and an easy-to-use C-compatible Foreign Function Interface (FFI). This article describes the first step in construction: JIT compilation of programs from a minimal language..."

To read this article and more, subscribe to The OCaml Journal today!

Solving the Traveling Salesman problem using Simulated Annealing

2009-01-09T17:40:00.000-08:00

The OCaml Journal just published an article about combinatorial optimization:

"Finding global minima of an arbitrary function is a significantly more challenging problem than local function minimization and has many practical applications from the simulation of molecules to the design of printed circuit board layouts. Several different global function minimization algorithms exist, many of which make repeated use of local function-minimization algorithms. This article describes a simple and elegant solution to the traveling salesman problem that uses the simulated annealing approach to global function minimization. The results are visualized in real time using OpenGL. In particular, we use an efficient purely functional data structure to represent the path..."

To read this article and more, subscribe to The OCaml Journal today!

Jane St. Capital expand their OCaml effort

2009-01-09T10:19:00.000-08:00

Financial trading company Jane Street Capital recently announced that their growing profits are to be ploughed back into the company that will now employ over 30 OCaml programmers, 50% up on the 20 programmers reported to have worked there only one year ago. This ossifies their position as the world's largest employer of OCaml programmers. Yaron Minsky of Jane St. also commented that they probably have the largest OCaml code base in the world as well, weighing in at just under one million lines of code.

Citrix take second place with just under 20 programmers contributing to their OCaml code base. However, previous news shows that the number of OCaml programmers at Citrix has been growing over 80% per annum since mid-2006.

Low-level optimization tips and tricks: part 2

2009-01-02T18:09:00.000-08:00

The OCaml Journal just published the second article in a series about low-level optimization:

To read this article and more, subscribe to The OCaml Journal today!

Working with Regular Expressions

2008-12-11T19:18:00.000-08:00

The OCaml Journal just published an article about regular expression for string manipulation:

"Regular expressions are a domain-specific language for pattern matching over sequences of characters. This functionality provides a concise and efficient way to dissect strings and, consequently, is used in many forms of string processing including the definition of lexers. This article describes OCaml's built-in support for regular expressions..."

To read this article and more, subscribe to The OCaml Journal today!

LLVM 2.4 released

2008-11-26T13:01:00.000-08:00

Developers of the compiler framework LLVM are sticking to a rapid release schedule, shipping the latest 2.4 version of LLVM. This includes extensive OCaml bindings that can be used to generate arbitrary native code at run time.

OCaml and LLVM form a powerful team that can be of mutual benefit in many different ways. Firstly, the OCaml language is derived from a family of languages that were specifically designed for manipulating programs and writing compilers. So OCaml is ideally suited for this task and many LLVM users stand to gain a lot by writing their high-level code (particularly front-ends) in OCaml. Secondly, the current OCaml implementation can be improved in many different ways using LLVM. One alluring project is the creation of an automated FFI for OCaml that uses run-time generated code to interface to existing native code libraries with a minimum of fuss by eliminating the impedance mismatch between the OCaml and C type systems and representations.

Using LLVM from OCaml has been the topic of two OCaml Journal articles already this year.

Object-oriented programming in OCaml

2008-11-24T20:07:00.000-08:00

The OCaml Journal just published an article about object oriented programming:

"The OCaml programming language is unique among member of the ML family because it provides not only the core ML features of variant types, pattern matching and functors but also two different features of the type system that provide subtyping: objects and polymorphic variants. Compared to conventional object-oriented languages, OCaml's objects are unusual because they are structurally typed, a characteristic that removed the need to declare class types but which can adversely affect developer productivity and run-time efficiency if used inappropriately. This article describes the design, implementation and use of OCaml's object system, giving references to examples of good design..."

To read this article and more, subscribe to The OCaml Journal today!

Stunning slides about the growth of OCaml at XenSource/Citrix

2008-11-24T13:24:00.001-08:00

In 2002, members of Cambridge University released the open source Xen project to provide free high-performance virtualization technology for the masses.

In 2004, the team founded the company XenSource and began developing the enterprise-level distributed management software that would make virtualization easy and form the backbone of their products in the years to come. A team of thirty dedicated programmers in Palo Alto California began developing the software in C, Python and Ruby.

Two years later, the US team had succeeded in burning tens of millions of dollars funding but had failed to produce any product. So XenSource, under new management, took the bold step of replacing their large team of US developers with a team of only four British OCaml developers. Within months, all of the Python and Ruby was replaced, both reliability and performance were dramatically improved and the company shipped their first product. One year later, XenSource sold to Citrix for $500M.

One of the first OCaml developers to join XenSource, Anil Madhavapeddy, stunned the audience at this years CUFP conference with the tale of Citrix growing from 4 to 18 OCaml developers since April 2006. Anil has kindly made his awe-inspiring slides available on-line.

Huffman data compression

2008-11-10T17:04:00.000-08:00

The OCaml Journal just published an article about data compression:

"Data compression algorithms are not only very useful in practice but are also extremely compelling pragmatic examples of programming theory. The popular Huffman data compression algorithm is from the family of entropy encoding compression algorithms. This article walks through the construction of a simple but efficient Huffman compressor and decompressor written entirely in OCaml..."

To read this article and more, subscribe to The OCaml Journal today!

Low-level optimization tips and tricks: part 1

2008-11-02T19:15:00.000-08:00

The OCaml Journal just published an article about optimization:

"The OCaml programming language is unusually well suited to high-performance computing among functional programming languages because it provides a highly efficient code generator with a performant run-time and garbage collector. This makes it feasible to write high performance programs entirely in OCaml without having to drop to lower-level languages like C and Fortran for performance-critical sections of code. This article describes the low-level optimizations that underpin the ability to write performant OCaml programs by leveraging knowledge about the OCaml compiler..."

To read this article and more, subscribe to The OCaml Journal today!

Largest order of OCaml for Scientists

2008-11-01T16:29:00.000-07:00

Cornell University recently placed the largest ever order of our book OCaml for Scientists in order to use our monograph as a text book for their students when teaching the awesome OCaml programming language. To date, OCaml for Scientists has sold hundreds of copies worldwide and continues to be one of our best selling products, having earned us 4.5× more profit than the average programming book.

If you would like to place a bulk order of OCaml for Scientists, please contact us.

Triangulated Irregular Networks (TINs)

2008-10-11T05:57:00.000-07:00

The OCaml Journal just published an article about computer graphics:

"Adaptive subdivision is a hot topic in computer graphics and forms the foundation of many state-of-the-art algorithms for large scale visualization used for everything from scientific visualization of huge data sets to game graphics that immerse players in expansive virtual worlds. This article describes one of the most popular approaches for the adaptive subdivision of 3D meshes and implements a capable plotting algorithm with real-time OpenGL-based visualization showcasing how this simple algorithm works and can be used to solve many different problems..."

To read this article and more, subscribe to The OCaml Journal today!

Oberon-2 compiler written in 6kLOC of OCaml

2008-10-08T20:14:00.000-07:00

Mike Spivey from the Computer Lab at Oxford University hosts the Oxford Oberon-2 compiler, which is written in OCaml with C for the Boehm-based run-time. The source code to the compiler is recommended reading for budding compiler writers using MLs such as OCaml.

Concurrent web crawling

2008-09-25T19:06:00.000-07:00

The OCaml Journal just published an article about concurrent web programming:

"Web-enabled technology is now ubiquitous and of huge commercial value. These kinds of programs share two common characteristics: they send information over the internet and they perform tasks concurrently. This article is the first in a series to examine the use of the OCaml programming language and its relatives in the growing area of concurrent web programming..."

To read this article and more, subscribe to The OCaml Journal today!

Building a 2D vector graphics library

2008-09-12T17:14:00.000-07:00

The OCaml Journal just published an article about vector graphics:

"Vector graphics represent images in terms of lines and curves on a fictional canvas. This resolution-independent representation is ideal for high resolution output devices such as printers but the inevitable march of technology has ossified vector graphics on the desktop as a fundamental component of both Apple's and Microsoft's latest operating systems. This article describes the design and implementation of a simple library for 2D vector graphics written in OCaml and using OpenGL for visualization..."

To read this article and more, subscribe to The OCaml Journal today!

LLVM tutorials ported to OCaml

2008-09-10T01:34:00.000-07:00

Erick Tryzelaar has done a fantastic job translating the LLVM tutorials from C++ to OCaml. The fruits of his labor are available here.

This tutorial describes the implementation of a compiler for the "Kaleidoscope" language including lexing, parsing, basic code generation using LLVM, JIT compilation using LLVM and the introduction of control flow and mutable variables.

LLVM is one of the world's most exciting open source projects and the early development of comprehensive OCaml bindings to LLVM has fuelled a great deal of cross-pollination.

Year long subscriptions to the OCaml Journal!

2008-09-08T19:22:00.000-07:00

Due to popular demand we have introduced year-long subscriptions to The OCaml Journal. Subscribers taking out 1 year subscriptions to both The OCaml Journal and The F#.NET Journal at the same time can currently benefit from a 25% discount!

OCaml on eight cores

2008-09-05T21:11:00.000-07:00

In preparation for OCaml's forthcoming parallel garbage collector, Flying Frog Consultancy have invested in an eight core computer. The machine is a Dell PowerEdge T605 with eight AMD Opteron cores and 4Gb of RAM.

Unable to resist temptation, we immediately reran the parallel ray tracer from the OCaml Journal article Fork-based parallelism and obtained near-optimal speedup when using all eight cores:

Watch this space for more parallel benchmarks using OCaml!

Writing a bytecode compiler using LLVM

2008-09-05T21:03:00.000-07:00

The OCaml Journal just published an article about the compilation of bytecodes:

"The Low-Level Virtual Machine (LLVM) provides the machinery to generate high-performance native code programmatically and on-demand. One of the most important applications of this technology is the Just In Time (JIT) compilation of bytecode intermediate representations into native code as found in Sun's Java Virtual Machine (JVM) and Microsoft's Common Language Runtime (CLR). This article describes how a simple bytecode interpreter can be developed into a JIT compiler using LLVM with relatively little effort..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml for Scientists now at least as cheap as ever!

2008-08-29T12:02:00.001-07:00

Many readers will already know that the OCaml programming language is widely used in the finance industry. What many people do not know is that workers in the finance industry often live on the bread line and, consequently, they have no choice but to find ways to obtain essential items cost effectively.

This appears to have been the case for our famous OCaml for Scientists book, which has seen its price slashed from US$170 to only US$155 in recent weeks thanks to some ingenious gambles made by workers in the finance industry helping to drive down the prices of essential European goods. Everyone in the US and other countries (like Canada) can now benefit from a cheaper but equally comprehensive OCaml for Scientists.

Fork-based Parallelism

2008-08-12T06:10:00.000-07:00

The OCaml Journal just published an article about parallel programming:

"As the world transitions to multicore desktop computers over the next few years it is essential that software evolves to take advantage of this new dimension in processing power by exposing parallelism. Although the current OCaml implementation has a serial run-time that limits multithreaded OCaml programs to serial concurrency, it is actually entirely possible to use separate processes to create parallel OCaml programs that do exploit multicores. This article examines a simple but powerful approach to parallelism using Unix process forking..."

To read this article and more, subscribe to The OCaml Journal today!

Growth of the OCaml job market

2008-07-28T14:25:00.000-07:00

Functional programming languages have been around for a long time, of course, but they have only very recently begun to be adopted for more mainstream programming tasks. This is reflected in the job market and the IT Jobs Watch website does an excellent job of trending job market trends over time for different programming languages, including OCaml. The results are nothing short of miraculous:

This shows that, at least in the UK, the OCaml job market is growing at an incredible rate: 12× as many OCaml jobs on the market as last year.

Moreover, the range of salaries for OCaml developers is substantially higher than all mainstream languages: £45-68k compared to only £38-45k for C# and £42-52k for Java. As we predicted last year, this trend is driven by employers using programming language diversity as a way to identify superior candidates and this trend is driving more and more young developers to better their programming abilities and job prospects by learning advanced languages like OCaml.

We believe this trend will continue for several years to come.

Metaprogramming with MetaOCaml

2008-07-27T19:31:00.000-07:00

The OCaml Journal just published an article about MetaOCaml:

"Metaprogramming is a term used to describe programs that generate or manipulate other programs. The ML family of languages were bred specifically for this purpose and, indeed, that is where their name MetaLanguage is derived from. Run-time compilation and execution of programs is a notable feature once present in Lisp as EVAL but sacrificed in the transition to ML. The MetaOCaml language is a prototype OCaml derivative that is designed to bring statically-typed metaprogramming to the OCaml family of languages. This article examines the use of MetaOCaml for metaprogramming including some of the practical applications of this technology and the challenges faced by users of this technology..."

To read this article and more, subscribe to The OCaml Journal today!

Calling C code from OCaml

2008-07-12T18:06:00.000-07:00

The OCaml Journal just published an article about OCaml's foreign function interface:

"Although the OCaml programming language offers many improvements over older languages such as C, C++ and Fortran the need to interoperate with native code can still arise. The two most important uses for native code interoperability are performance and legacy. This article describes how native code can be invoked from OCaml programs using both the conventional OCaml approach of writing stub functions in C and also a new approach using LLVM to generate the necessary interface code at run-time..."

To read this article and more, subscribe to The OCaml Journal today!

Tricks with recursion: knots, modules and polymorphism

2008-06-24T05:01:00.000-07:00

The OCaml Journal just published an article about recursive type and function definitions:

"This article introduces some of the design patterns found in functional programming. The phrase "untying the recursive knot" refers to the ability to remove direct recursion from value and type definitions through the use of parameterization. OCaml's recursive modules allow recursion to cross module boundaries. Polymorphic recursion allows functions to call themselves with different type parameters. This article introduces all of these functional design patterns with illustrations and worked examples..."

To read this article and more, subscribe to The OCaml Journal today!

Real-time Finite Element Materials simulation

2008-06-13T03:04:00.000-07:00

The OCaml Journal just published an article about real-time simulation:

"Finite Element Materials simulations (FEMs) model a continuous volume of material by breaking it down into a discrete representation with many finite parts. This article describes a simple but fun program that simulates the dynamics of a 2D system of particles and springs in real-time. The program visualizes the results using OpenGL..."

To read this article and more, subscribe to The OCaml Journal today!

Implementing a simple XML-RPC client and server

2008-05-26T04:49:00.000-07:00

The OCaml Journal just published an article explaining how both producers and consumers of remote procedure calls can be written in OCaml:

"XML-RPC is a protocol for remote procedure calls that is built upon the XML format. Method calls are packaged up by the client as an XML request sent via HTTP to the server whereupon action is taken and a response is packaged up and returned in the same way. This article describes how a complete client-server pair using XML-RPC can be designed and built from scratch in OCaml using only the XML-Light and OcamlNet libraries..."

To read this article and more, subscribe to The OCaml Journal today!

Porting and optimizing the SciMark2 benchmark

2008-05-12T18:32:00.000-07:00

The OCaml Journal just published an article about the SciMark2 benchmark:

"The SciMark2 benchmark is a suite of numerical algorithms that were originally collated into a benchmark for scientific computing on the Java platform. Porting this benchmark to OCaml provides an excellent tutorial on the implementation of efficient numerical algorithms using the current OCaml implementation. The results illustrate the strengths and weaknesses of the current OCaml implementation in terms of performance..."

To read this article and more, subscribe to The OCaml Journal today!

Language oriented programming: Term Rewriting

2008-04-28T06:08:00.000-07:00

The OCaml Journal just published an article describing term rewriting:

"An interesting and powerful alternative to the conventional term-level interpreter is called term rewriting. Rather than reducing expressions down to values, term rewriting simply evaluates expressions by performing substitutions and the result is another expression. This approach is particularly well suited to computer algebra systems such as Mathematica but is also an underappreciated alternative to dynamically-typed programming languages that can integrate useful features like pattern matching and make techniques like partial specialization far easier. This article describes how a simple term rewriter can be constructed and introduces the concept of private variant type constructors in the process..."

To read this article and more, subscribe to The OCaml Journal today!

OCaml to get Concurrent Garbage Collection

2008-04-28T05:28:00.000-07:00

Following our exploits with Microsoft's F# programming language, which inherits a concurrent garbage collector from their excellent common-language run-time (CLR) implementation, we have been wondering if OCaml would ever acquire a concurrent GC of its own. Concurrent garbage collection is tremendously useful in a wide variety of circumstances and is of increasing importance as the world transitions to multicore CPUs for desktop computers. Compared to OCaml, concurrency in F# makes it much easier to spawn interactive visualizations from the top-level, write high performance parallel numerical codes and keep GUI applications fluid.

The developers of OCaml at INRIA in France, led by Xavier Leroy, have long since given up on developing their own concurrent GC for OCaml, famously stating in 2002 that developing their own concurrent GC was "Too complex" and "too hard to debug".

Fortunately, Jane St. Capital (one of the largest industrial users of OCaml) have chosen to fund a "multicore" summer project that aims to provide a basic concurrent garbage collector implementation for OCaml. The team from the Université Pierre et Marie Curie, led by Emmanuel Chailloux, intend to complete this project during the summer of 2008.

We have already written to team to suggest that they might also make their run-time compatible with the excellent LLVM project because this would make it much easier for open source developers to reuse this exciting technology.

Labeled and Optional arguments

2008-04-11T06:02:00.000-07:00

The OCaml Journal just published an article describing the use of labeled and optional function arguments:

"The OCaml programming language provides a variety of useful features that are not found in many other functional programming languages. This is why OCaml is widely accepted as a functional language for practical use. Labeled and optional function arguments are two related features that can be used to great effect in simplifying interfaces. This article introduces the syntax required to define and use both labeled and optional arguments in OCaml and describes some pedagogical uses of these features, with references to existing libraries, as well as examining some of the problems often encountered by programmers using these features..."

To read this article and more, subscribe to The OCaml Journal today!

Nice ray tracer in OCaml

2008-03-28T08:11:00.000-07:00

The Bla Repository just posted an interesting ray tracer example, written entirely in OCaml.

Getting the most out of Static Typing

2008-03-27T10:48:00.000-07:00

The OCaml Journal just published an article explaining how OCaml's static type system can be leveraged to improve program reliability and development speed:

"The OCaml language arms programmers with one of the most sophisticated static type systems of any general-purpose programming language. This static type system can be used to remove large classes of common bugs that are otherwise tedious or impossible to track down. The benefits in terms of programmer productivity and program reliability are tremendous. However, leveraging such a type system is an art that requires significant effort to learn. This article describes idiomatic OCaml style and a variety of techniques that can be used to leverage the static type system in order to catch errors earlier and more easily..."

To read this article and more, subscribe to The OCaml Journal today!

Run-time compilation with LLVM

2008-03-09T15:09:00.000-07:00

The OCaml Journal just published an article describing basic use of the LLVM library:

"The Low-Level Virtual Machine (LLVM) project brings high-performance static and JIT compilation to code generators written in the OCaml programming language. This article describes the basic use of LLVM from OCaml including both static and JIT compilation, argument passing, control flow and the compilation of expression trees..."

To read this article and more, subscribe to The OCaml Journal today!

Book Review: OCaml for Scientists

2008-03-01T01:47:00.000-08:00

Fabrice Marchant has kindly written and published the following review (also available in French) of the book OCaml for Scientists:

"I have read OCaml for Scientists, the work of Dr Jon Harrop, which is dedicated to the OCaml programming language. Even though science and technical computing are inherent aspects of this book this is not restrictive with the exception of a few complicated examples in the final chapter.

The OCaml language combines functional and imperative programming. It is very fast and has garbage collection. Type inference makes coding particularly concise, safe and easy. OCaml's embedded module language and object orientation form a powerful software engineering tool.

Without requiring knowledge of ML-type languages, OCaml for Scientists teaches the reader how to use OCaml for scientific computing, including the use of several powerful libraries among the examples.

There are few prerequisites for correctly following the book because the author introduces the classical concepts of programming (such as recursion) before progressively developing.

That being said, the knowledge of an imperative programming language (like C or Pascal) or a functional one (such as Lisp or Scheme) is not absolutely required but would make the book more straightforward.

An important part, at the beginning of the book, is dedicated to a proper understanding of the language itself: here one finds coverage of the functionalities offered by OCaml's many keywords, illustrated by numerous clear examples.

This book does not content itself with being only a tutorial of the language. The author shows the proper usage of the possibilities of OCaml - such as the best programming practices - and often goes further in justifying things by studying the internal representation used by the compiler.

Working side-by-side with practical examples, the clarity of the exposition of this part of the book constitutes what is probably one of the most efficient mediums offered to the beginner, to rapidly acquire an understanding of the basic language necessary to program.

Dr Harrop teaches things in such a manner that reading is always easy, even when covering non-trivial scientific subjects. The syntactic coloration, on large white pages, makes the book pleasant to open.

These two aspects work together to give an impression of clarity and simplicity.

The book, stuffed with examples, has a practical view of the different programming components comprising the OCaml system: The customisable top-level, the many compilers, the dependency visualiser and profiler, are all presented together with their usage.

The book's examples are worth a special mention. With the exception of the contents page, it is difficult to find a page which does not present several concrete examples of programming. Some of them are surprisingly elaborate.

Similarly, on the practical side: The use of certain libraries, such as "command line arguments, big arrays, vector matrix and lexing and parsing, are presented in detail.

Despite the scientific focus, the first few chapters are of general interest.
Other parts such as visualisation (with OpenGL) or lexing and parsing, are perhaps particularly useful for game designers.

In addition to OCaml for Scientists, I own "Programmation fonctionnelle, générique et objet (Une introduction avec le langage OCaml)" by Philippe Narbel. The two works complement each other, OCaml for Scientists being more concrete. To cite only the unique parts of OCaml for Scientists, it presents libraries and studies optimisation in detail.

Certainly, IMHO, a section detailing the writing of functors would have been welcome. However, studying the book gives an understanding of the language such that one can undertake substantial programming projects.

The book, preceded by a glossary, is divided into ten thick chapters:

Introduction, Program Structure, Data Structures, Numérical Analysis, Input and Output, Visualization, Optimization, Libraries, Simple Examples and Complete Examples, Bibliography, Advanced Topics and Troubleshouting.

To conclude, OCaml for Scientists is an excellent book, clear and practical, which can be used as a reference work."