OCaml Weekly News

Hi folks! :wave: wanted to share something I’ve been working on these last few weeks.

Riot is an actor-model multi-core scheduler for OCaml 5. It brings Erlang-style concurrency to the language, where lightweight processes communicate via typed message-passing.

Caper has reached v0.9. It is a tool for understanding and processing “pcap expressions” (also known as tcpdump filters) which are used for network packet analysis. It is entirely written in OCaml and includes pcap analysis logic, a from-scratch BPF compiler, and conversion to/from English expressions.

You can use Caper online through the BPF Exam site.

Caper’s README contains motivation, building, and usage examples, and its CHANGELOG describes recent updates.

A huge thanks goes to Caper’s contributers. Further contributions and feedback are welcome – a list of contribution ideas is included on Caper’s web page.

Hi everyone,

we are delighted to announce the OCaml User Survey, 2023 edition. With this survey, the OCSF is trying to get a better picture of the OCaml community and its needs. It would be very helpful if you could take a few minutes (10 to 15) to fill the survey and share it with other OCaml programmers.

https://forms.gle/iteoR7QMzFXw2mp89

The survey is run by the OCaml Software Foundation . It builds on previous iterations. The results will be published here on discuss and on the website of the OCSF . The OCSF would like to thank all the people that have helped in devising this or previous versions of the survey. Don’t hesitate to give us your feedback (you can post here or send me a message/email).

The survey will remain opened until December 8th 2023 (AOE). Please take the survey and don’t hesitate to share the link!

Some remarks regarding this year’s survey:

• Most of the questions are similar to the ones in the previous survey, some have been fixed, some have been updated (e.g. to list more recent versions of the OCaml compiler)
• A new section at the end on Demographics, Diversity and Inclusion. The related questions are more personal but again completely optional and would greatly help us get a better picture of our community and areas were the OCSF can help improve things
• Again, we resorted to using Google Forms. I spent quite some time trying to find a viable alternative, but none were satisfactory (either from a technical, accessibility or bureaucratic point of view). I understand that this can be a disappointment for some. If you are interested in running the survey next year on behalf of the OCSF, get in touch!

This release contains a workaround for an upstream issue that is causing post process to become incredibly slow. If you would like to access related information, check out the PR. https://github.com/ocaml/setup-ocaml/pull/724

https://github.com/ocaml/setup-ocaml/releases/tag/v2.1.2

Welcome to the October 2023 edition of the OCaml.org newsletter! This update has been compiled by the OCaml.org team. You can find previous updates on Discuss.

Our goal is to make OCaml.org the best resource for anyone who wants to get started and be productive in OCaml. The OCaml.org newsletter provides an update on our progress towards that goal and an overview of the changes we are working on.

We couldn’t do it without all the amazing OCaml community members who help us review, revise, and create better OCaml documentation. Your feedback enables us to better prioritize our work and make progress towards our goal. Thank you!

This month, our priorities were:

• Learn Area: We continue our efforts to make OCaml.org a great resource for learning OCaml. This month, we’ve validated a new version of the designs for the Learn area, and we’ve published two new documentation pages!
• Outreachy Internship Application Period: OCaml.org is participating in the Outreachy Internship Program with two internship projects. As part of the application period, we’ve received tons of fantastic contributions from Outreachy applicants!
• General Improvements: As usual, we also worked on general maintenance and improvements based on user feedback, so we’re highlighting some of our work below.

Small addition to allow checking if a node or attr is ’null’ (i.e. empty). This can be useful when you get a node or attr passed in to your function and you need to decide what to render depending on whether it’s empty or not.

As a reminder, ’null’ or empty nodes and attributes are ones which are simply not rendered into the final HTML.

Dear OCamlers,

The OCaml.org continues working on new tutorials. We have a draft on polymorphic variants; we’d like your feedback on it:

• GH PR: https://github.com/ocaml/ocaml.org/pull/1531
• Online draft: https://staging.ocaml.org/docs/polymorphic-variants

Previously announced tutorials form a series.

1. Installing OCaml
2. A Tour of OCaml
3. Your First OCaml Program
4. Values and Functions
5. Basic Datatypes and Pattern Matching

But this one is not intended to follow right after those. It is designed to be taken by people familiar with OCaml’s basics and willing to master polymorphic variants.

As a draft, it has gaps, most notably:

• The section on Performance Drawbacks needs to be strengthened
• An example inspired by @garrigue “Code reuse through polymorphic variants” paper is missing

Share your feedback here or in GitHub, but do not use the “Contribute” link at the bottom of the page.

Hope it helps

It was a nice and short meeting with @ceastlund and me. Here are the meeting notes: https://github.com/ocaml-ppx/ppxlib/wiki/Dev-meeting-21-11-2023

Hello everyone,

I’m not so pleased to announce a bugfix release of the varray package on opam. This library provides an implementation of dynamic arrays, which automatically resize as elements are added or removed from the array. It’s based on the really fun paper “Tiered Vectors: Efficient Dynamic Arrays for Rank-Based Sequences” by Michael T. Goodrich and John G. Kloss II. When I first heard about it, I could not resist implementing this datastructure because its algorithmic complexities are rather fancy:

• O(1) to get/set elements anywhere in the array
• O(1) to add or pop an element at the front/back of the array
• O(ᵏ√N) to add or pop an element anywhere in the middle of the array (for any k >= 1)

And because there’s a fun way of exposing the API using OCaml’s functors:

module One   = Varray.Circular   (* k=1 => O(N) complexity for insert/delete *)
module Two   = Varray.Root (One) (* k=2 => O(√N) complexity *)
module Three = Varray.Root (Two) (* k=3 => O(³√N) complexity *)

More details on the github repo and the online API documentation (which includes a teaser for odoc upcoming search feature, thanks to @EmileTrotignon, @panglesd and the wonderful odoc team :heart: )

Yet, I never publicly announced the initial release of this package on opam… because I don’t think dynamic arrays are actually useful when programming in OCaml! Using integer indices to address elements is prone to “index out of bounds” bugs, so it’s rarely the right choice. If you do have a usecase for them, I would love to hear it :)

—

But ok, so, wait, why am I announcing it now? Well because @n-osborne found a bug in my code which could trigger a segfault! This terrible bug was only affecting the lesser-used delete_at operation, and so it lay dormant for two years. This was a very dumb mistake: This specific function was missing a check for out of bound indexes (ha!)

While I would prefer to avoid the public walk of shame, how the bug was discovered is too cool not to share: @n-osborne and @shym wrote a Gospel specification of how the Varray library should behave, which enabled them to stress test it and discover a counter-example where my code was misbehaving. Here’s an extract of the faulty function specification, where Gospel specs are written as special comments (*@ ... *) in the mli documentation:

type 'a t
(*@ mutable model contents : 'a sequence *)
(* ^^^ Gospel modelization of the abstract varray type
       as a "mutable sequence called contents" *)

val delete_at : 'a t -> int -> unit
(** [delete_at t i] removes the element [t.(i)].
    Every element on the right of [i] is shifted by one to the left. *)
(*@ delete_at t i
    checks inside i t.contents
    modifies t.contents
    ensures t.contents = old (t.contents[..(i - 1)] ++ t.contents[(i + 1)..]) *)

Note the use of the keyword old on the last line, which allows the postcondition ensures to refer to the state of the input before it was imperatively modified. Formal specifications are generally reserved to specialists, but look how readable this is! (see the full varray spec)

Gospel specs can then be interpreted by a variety of tools. To discover this specific bug, @n-osborne used Ortac to automatically translate his specification into an executable QCheck-STM test to search for incoherencies between the model and the actual implementation.

Very very cool stuff. If you are looking for more resources on the subject, I found Chapter 2 of Clément Pascutto’s PhD thesis to be a very nice introduction to Gospel specifications :) (and later chapters describe his cutting edge research for Ortac!)

For those speaking french and interested in Gospal/Ortac, there’s a video of Clément’s talk given at the oups meetup last year.

Hi all! I’m pleased to announce the first release of urn a library that implements urns, a very nifty pure functional data structure for randomly sampling with or without replacement from weighted discrete distributions in log time. It provides implementations for using ~int~s and ~float~s as weights, though it can be extended to any number like thing that can be uniformly sampled from.

The package is available through opam with opam install urn, and is distributed under the MIT license.

Dear OCamlers,

The OCaml.org team has yet another draft tutorial. This time, the title is: “Mutability, Loops, and Imperative Programming”. We want your feedback on it:

• GH PR: Tutorial on Mutability and Imperative Programming
• Online draft: Mutability, Loops, and Imperative Programming

The target audience is developers learning OCaml. No functional programming knowledge is assumed. However, it comes after the “Get Started” series:

1. Installing OCaml
2. A Tour of OCaml
3. Your First OCaml Program

And it comes at the end of the “Introduction” series:

1. Values and Functions
2. Basic Datatypes and Pattern Matching
3. If Statements and Recursions
4. Lists
5. Labelled & Optional Arguments
6. Mutability, Loops, and Imperative Programming

As the previously announced draft on polymorphic variants this one contains overlooked issues. We want to make it better with your help.

Share your feedback here or in GitHub, but do not use the “Contribute” link at the bottom of the staging page.

Hope it helps

Hi everyone!

I am happy to announce the release of pretty_expressive, an implementation of A Pretty Expressive Printer (OOPSLA’23).

• Documentation
• Project page
• opam: opam install pretty_expressive

Unlike other pretty printers in the OCaml ecosystem which are mostly focused on the OCaml style (as far as I can tell), pretty_expressive is general-purpose, making it suitable for formatting various styles (the pretty printer was originally created to format programs in the Racket language). pretty_expressive is further distinguished from other general-purpose pretty printers (e.g., Hughes’, Wadler’s, Bernardy’s) by its expressiveness and optimality.

This is also my first OCaml project (not counting Reason). Any feedback is welcome!

Thanks, Sorawee

Here are links from many OCaml blogs aggregated at the ocaml.org blog.

• How to Install OCaml 5: A Video Tutorial