OCaml Weekly News

I've written a new blog post on the living library I announced a few days ago. Please give it a read if you're interested in safe use of Ctypes, or otherwise need lifetime management in OCaml.

Would love to hear your views in this thread!

https://fizzixnerd.com/blog/2024-07-17-touring-the-living-library/

I'm happy to announce the first release of rpmfile, a small library for reading meta information from RPM packages (version 3.0). It uses the Angstrom combinator parser library, which allows it to perform streaming parsing using Lwt or Async.

How to get a package summary:

module Rpm_reader = Rpmfile.Reader (Rpmfile.Selector.All)

let metadata = Rpm_reader.of_file_exn "hello-2.12.1-1.7.x86_64.rpm"

Rpmfile.summary metadata
(* - : string = "A Friendly Greeting Program" *)

The default reader module can read from a string or file, but has poor performance. It needs a selector module to select the tags to parse. The example uses Selector.All to parse all tags.

I am developing this library for my pet project to create a self-hosted RPM repository management solution.

Thank you for your attention!

We are organizing a new public Dune dev meeting on Wednesday, July, 24th at 10am CET. It will be one hour long.

Whether you are a maintainer, a regular contributor, a new joiner or just curious, feel free to join! The goal of these meetings is to provide a place to discuss the ongoing work together :smile: Below, you can find the agenda for this meeting:

New blog post about fixing the mistakes in the living library. Please take a look if you're interested in interfacing ocaml with external resources.

https://fizzixnerd.com/blog/2024-07-21-fixing-living/

In particular, I think the library comes good with its guarantees now that

1. if every function is properly dependent, and
2. you only unsafe_free values that are disjoint from their dependencies, then

you will obtain a sound program when using the Ctypes ffi, in terms of there being no use-after-free errors.

Please let me know if you disagree!

I needed a few functions which were missing in the OCaml library : Bigarray.Genarray, and decided to write them for my own purpose :

• Iteration on genarrays
• mapping on genarrays
• folding on genarrays

Today I believe this can be usefull for others, and may suffer a code inspection as I am not that experienced in OCaml. I am ready to have this piece of code evolve if it is usefull so even (and maybe first) a feedback on the usefullness of such code is welcome.

The only alternative I was given was the famous Owl library, which was way to heavy for my needs, and not easily usable (if not understandable). This extension is very simple, it is its strenght. Ultimately, it could be merged in the standard library … maybe after some work indeed : you tell me.

There is a clean documentation I guess, hope this can help : GenArrayIter

Looking forward to hearing from you all.

Hi! I'm happy to share cudajit 0.4.0: manually-selected bindings for Nvidia GPU programming. cudajit should soon propagate to the opam repository. Bindings to the cuda and nvrtc libraries with a unified interface API documentation Currently supported:

• Compiling a kernel with conversion to PTX, launching a kernel.
• Synchronous and asynchronous memory copying.
• Contexts and streams.
• (GPU) device attributes.

Currently not supported:

• Events.
• CUDA graph features.
• Cooperative kernel launch.

Let me know your needs so I can prioritize. PRs are also welcome!

Hello again, everyone. :wave: Today I want to tell you about what has changed in a new version of my rpmfile library (previous topic) for reading meta-information from RPM packages.Should I post this in the forum? I'm sorry.

To OCaml & Docusaurus enthusiasts out there :camel:+ :sauropod:

Some time ago, I shared my experience using Docusaurus to document an OCaml project, highlighting the integration between Docusaurus, ocaml-mdx, and the dune workflow (previous post here).

Today I wanted to share that I've resumed this exploration in documentation tools to try and integrate odoc-generated pages into Docusaurus, with the aim of creating a somewhat minimal template/example for this.

I've published my experiment here: https://mbarbin.github.io/doc-experiment-docusaurus/.

Integrating odoc posed challenges - I've written about the (pragmatic) approach I took here. I'm linking this odoc issue too, for reference about exploring more native solutions for this interop.

Have you too tried this "magic combo" of Docusaurus, Odoc, and OCaml tools? And if so, how did you approach it? Do you have insights or suggestions? If this sparks your curiosity, please don't hesitate to engage with the repository.

On behalf of all its developers, I am glad to announce the release of Mopsa 1.0! You can just opam install mopsa.

Mopsa stands for Modular and Open Platform for Static Analysis. It aims at easing the development and use of static analyzers. More specifically, Mopsa is a generic framework for building sound static analyzer based on the theory of abstract interpretation. Mopsa is independent of language and abstraction choices. Developers are free to add arbitrary abstractions (numeric, pointer, memory, etc.) and syntax iterators for new languages. Mopsa encourages the development of independent abstractions which can cooperate or be combined to improve precision.

Mopsa currently support the analysis of Python, C and Python+C programs. It reports run-time errors on C programs and uncaught exceptions on Python programs. Our benchmarks provide an illustrative overview of what Mopsa can currently analyze. All analyses currently provided are flow and context-sensitive (i.e, control-flow operators are taken into account by the analysis, and functions are analyzed by virtual inlining). The C analysis is actively developed and maintained. The Python and Python+C analyses work on real-world examples, but are not actively developed.

Please note that Mopsa is an academic tool under development. Feel free to submit issues if you encounter any bug!

Additional resources:

• user manual
• demo of our abstract debugger
• academic overview of Mopsa, and in a PhD thesis
• coreutils benchmarks on which Mopsa can run

I've been trying out some tools to investigate performance problems in my OCaml programs and I've written up my experiences here in case other people find it useful:

• https://roscidus.com/blog/blog/2024/07/22/performance/
• https://roscidus.com/blog/blog/2024/07/22/performance-2/

The first post examines a case of slow IO in a concurrent Eio program, and the second looks at poor GC performance in a multicore app.

In particular, it seems that minor GC performance is very sensitive to other work running on the machine, since any domain being late will trigger the others to sleep, e.g.

I'd be interested to know if others can shed more light on this, or have other profiling tools they've found useful.

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

• OCaml 5 performance part 2
• OCaml 5 performance problems
• OCaml Compiler Manual HTML Generation