OCaml Weekly News

I’m pleased to announce that the OCaml NYC Meetup is back! We have scheduled our first new event for June 20th, where we will discuss the use of OCaml in Tezos. Please join the meetup group to stay informed about future events. We normally will not post to this forum.

We are always looking for speakers. Please reach out to me if you are in the New York City area and are interested in giving a talk.

This tutorial is now online: https://ocaml.org/docs/sequences

Thanks to Miod Vallat, Sayo Bamigdade (@SaySayo), Christine Rose (@professor.rose), Sabine Schmaltz (@sabine), Guillaume Petiot (@gpetiot), Xavier Van de Woestyne (@xvw) and Simon Cruanes (@c-cube ) for their feedback

I am pleased to announce a new release of Merlin!

Merlin is an editor service that provides modern IDE features for OCaml.

This new release brings a number of improvements and bug fixes. In particular we identified and patched an important memory consumption issue that could greatly affect Merlin’s performance in heavily functorized projects.

Full changelog: https://github.com/ocaml/merlin/blob/master/CHANGES.md#merlin-49

we have an open PR on ocaml/ocaml.org (https://github.com/ocaml/ocaml.org/pull/1226) to show an approximation of what the state of the OCaml ecosystem is with respect to different topics / use cases.

This addition is inspired by Rust’s excellent “Are we X yet?” pages which

1. highlight libraries that are production-ready, well-documented, and have a nice API in the different categories. This is a showcase where we want to proudly point newcomers to.
2. offer a high-level overview of the usability of the language for certain applications. This makes visible where contributions to the ecosystem would be particularly valuable to the OCaml community. They provide a starting point for (prospective) package authors to see where gaps in the ecosystem are, so they can create successful open source projects that meet community demand! (I know at least one company which is interested in contributing to funding such projects. :wink:)

This is where you come in:

1. Please help us give these pages an iconic name / title. Got an idea? Reply to this post! Make it memorable.
2. Are there any important categories missing?
3. Contributions are always welcome - none of use here is an expert on the ever-growing OCaml ecosystem!

I’m happy to announce a new release of DocuLib on OPAM, a lightweight and easy to use GUI for locally managing metadata for books, textbooks, and articles (kind of like Zotero). This release is mostly for minor fixes but I want to take the opportunity to advertise DocuLib again.

Its core features are

• facilitating looking up metadata with an interface to openlibrary.org, semanticscholar.org, and bibtex references through crossref.org
• automatically detecting duplicates (by md5 hash), file renamings, and files moved between libraries without losing metadata
• keeping track of authors, title, tags, personal notes, date, DOI/ISBN
• error permissive search

For a full list of changes see CHANGES

Feel free to make suggestions in the comments!

Could you comment a bit more on the comparison to zotero? Are there certain features in doculib that you can’t easily achieve in zotero?

The biggest difference is the way data is stored:

• Zotero puts a priority on metadata entries where a physical file is a child of that entry if it exists, whereas DocuLib entries are one-to-one with physical files on your computer
• files added to Zotero are either stored in a Zotero data directory (over which you have no control) or a link to a file on your computer (which you have to keep track of manually, so clearly not the preferred method), whereas DocuLib files are stored in libraries, of which you can have multiple. A library is a directory containing files you want DocuLib to index, but metadata for that library is also stored in that library.This means libraries are portable, so you can share them or sync them independently of DocuLib.
• Zotero stores metadata in a database, whereas DocuLib stores metadata as json files one-to-one with the corresponding document

So in short, use DocuLib if you are a document hoarder and want local control over your files. I’d say creating bibliographic references is not the primary focus of DocuLib, whereas it is for Zotero.

We are pleased to announce the patch release of opam 2.1.5.

This opam release consists of backported bug fixes & a security fix.

You’ll find more information in the release blog post, and the local cache corruption issue in the security post.

Thanks to robur for the security review!

To upgrade simply run:

bash -c "sh <(curl -fsSL https://raw.githubusercontent.com/ocaml/opam/master/shell/install.sh) --version 2.1.5"

The dune team is pleased to announce the release of Dune 3.8.0.

It is now available in opam-repository. As usual, it should always be safe to upgrade your dune package: new features and deprecations are only availble if you upgrade the language version in your dune-project files.

With the progress of the ongoing stabilisation effort for OCaml 5.1.0, I am happy to announce a second alpha release for OCaml 5.1.0.

This second alpha release contains many noteworthy fixes:

• a long-awaited GC fix
• a Windows ABI fix

as announced in the first alpha but also

• a compiler-libs (parsetree) fix
• a type system compatibility enhancement change
• a restored backed for s390x/IBM Z

The full list of changes since the first alpha is available below.

Once most major OCaml tools are updated to the last compiler-libs changes, we will switch to beta releases. Hopefully, this will happen in the upcoming weeks. The progress on stabilising the ecosystem is tracked on the opam readiness for 5.1.0 meta-issue.

Currently, the release is still planned for around July.

If you find any bugs, please report them on OCaml’s issue tracker.

If you are interested in the ongoing list of new features and bug fixes, the updated change log for OCaml 5.1.0 is available on GitHub.

I’m letting you know that the deadline has been extended to June 8th (AoE).

I’m happy to share release 0.2 of qcheck-lin and qcheck-stm for black-box property-based testing.

• qcheck-lin requires little more than an interface description. It allows to test a library for sequential consistency, that is, whether results obtained from using it in parallel agree with some linear, single domain execution.
• qcheck-stm is a model-based, state-machine framework for both sequential and parallel testing. It allows to test an imperative interface against a pure model description, and thereby allows to express and test intended behaviour beyond a signature description.

For example, here’s a minimal qcheck-lin test of a selection of the Stdlib Hashtbl interface:

module HashtblSig =
struct
  type t = (char, int) Hashtbl.t
  let init () = Hashtbl.create ~random:false 42
  let cleanup _ = ()

  open Lin
  let a,b = char_printable,nat_small
  let api =
    [ val_ "Hashtbl.add"    Hashtbl.add    (t @-> a @-> b @-> returning unit);
      val_ "Hashtbl.remove" Hashtbl.remove (t @-> a @-> returning unit);
      val_ "Hashtbl.find"   Hashtbl.find   (t @-> a @-> returning_or_exc b);
      val_ "Hashtbl.mem"    Hashtbl.mem    (t @-> a @-> returning bool);
      val_ "Hashtbl.length" Hashtbl.length (t @-> returning int); ]
end

module HT = Lin_domain.Make(HashtblSig)
;;
QCheck_base_runner.run_tests_main [
  HT.lin_test ~count:1000 ~name:"Hashtbl DSL test";
]

Running this test quickly finds a minimal counterexample to illustrate that Hashtbl is not safe to use in parallel:

Messages for test Hashtbl DSL test:

  Results incompatible with sequential execution

                                    |
                        Hashtbl.add t '<' 0 : ()
                                    |
                 .------------------------------------.
                 |                                    |
     Hashtbl.add t 'a' 0 : ()             Hashtbl.remove t '<' : ()
       Hashtbl.length t : 0

We presented preliminary work on both these libraries at the OCaml Workshop 2022. The libraries furthermore underlie our continuing effort to test the multicore runtime of OCaml 5.x, and have helped identify several issues.

The 0.2 release adds a range of features and bugfixes, including support for OCaml 4.12.x, 4.13.x and 4.14.x without the Domain and Effect modes.

Detailed release notes and more information is available from the GitHub repository: https://github.com/ocaml-multicore/multicoretests

Happy testing!

The Melange team and I are thrilled to announce the release of Melange 1.0 today, marking a major milestone in the life of the project. This release represents the culmination of many months of hard work and incredible collaboration.

Melange, which started as a fork of BuckleScript, was created with the vision of maintaining compatibility with OCaml and providing the best OCaml experience within the modern JavaScript ecosystem. Today, we are proud to present Melange 1.0, a mature and reliable tool for compiling OCaml to efficient and readable JavaScript that teams rely on to deliver complex OCaml / ReasonML applications.

Get it now:

$ opam install melange.1.0.0

In response to an earlier post (https://discuss.ocaml.org/t/enhancing-ocaml-debugging-experience-in-visual-studio-code/12236/4?u=jbeckford) I’ve uploaded a video on YouTube.

Direct Link: https://youtu.be/OV19_FqAUCw

Quick Summary: Pre-requisite skill is the ability to compile your own OCaml compiler. Only macOS and Linux. Breakpoints and single-stepping; no display of OCaml values.

Hopefully it will be the first of several if a few people subscribe or comment. The video, and others that I may make for that new channel, are not for OCaml beginners.

Aside: Personally, I don’t become a beginner in a new subject without first having a glimpse of what I can accomplish in that subject. My expectation is that the people curious about OCaml may land on a few videos and then become beginners.

Since this is my very first YouTube video, I’d appreciate feedback!

Sandmark nightly now monitors tail latency of sequential and parallel applications enabled by new features in OCaml 5.

Click to see the Sequential latency benchmark run

Click here to see the Parallel latency benchmark run

With Eio 0.10 just released, it’s time for another update! Since the above post (which was for Eio 0.5), some of the bigger changes are:

• A new eio_posix backed for Unix-type systems provides much better performance than the old libuv one. Removing libuv has also made it safe to share file-descriptors between domains, so you can now accept a connection with one domain and handle it with another, for example.
• There is now an API for spawning sub-processes.
• Networking changes include better support for datagram sockets and the new Eio.Net.run_server convenience function.
• Many of the data-structures (promises, conditions, semaphores and synchronous streams) are now lock-free, making them faster to use across multiple domains.
• It is safe to handle signals in Eio now that Eio.Condition.broadcast is lock-free (signal handlers can’t take locks, since they may have interrupted the thread holding the lock). Though note that reliable signal handling on OCaml 5 requires OCaml#12253 to be fixed too.
• Fiber.fork_seq provides an easy way to create generator functions.
• Eio now supports domain-local-await, which allows sharing e.g. kcas data-structures across Eio and Domainslib domains.
• Error handling has been improved. You can now add extra context information to errors (e.g. an error opening a missing file will now include the path of the file). You can also choose how specific to be: e.g. you can catch all IO errors, all network errors, or all connection reset errors.
• There are also some experimental backends under development:
  • eio_solo5 is for MirageOS unikernels.
  • eio_js is for browsers.
  • eio_windows is for Windows - see #125 if you’d like to help out.

A more detailed list of changes can be found in the release notes.

Eio’s README.md provides an introduction to most of the features.

If you’d like to get involved, the new HACKING.md document explains the structure of the code for people who want to contribute to Eio, and there are regular Eio developer meetings for anyone who wants to get involved.

I’m happy to announce that some initial emissions monitoring has been added to the OCaml.org infrastructure. A more detailed write up can be found at https://infra.ocaml.org/2023/05/30/emissions-monitoring.html. This is a first step in accurately measuring the amount of emissions we are generating. There was a discuss thread touching on some of this a while ago https://discuss.ocaml.org/t/ocaml-carbon-footprint/8580.

I think there are two important next tasks: getting full coverage of all of the infrastructure machines and making the data publicly available. I hope to work on this (in an open-source way) in the future, if anyone else is interested do let me know!

Thanks to Tarides (who funded the initial work on this) and to @lambda_foo, Mark Elvers and @avsm for helping with the deployment and ideas for measuring emissions. There is an issue on the ocaml/infrastructure repository for the next steps https://github.com/ocaml/infrastructure/issues/47 :seedling:

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

• Two variants of the Bind rule
• Oxidizing OCaml: Locality
• The Future of Programming with Richard Eisenberg
• Beta release of Frama-C 27.0~beta (Cobalt)
• Specifying Functions: Two Styles