[Caml-list] Attn: Development Editor, Latest OCaml Weekly News

Alan Schmitt
2024-09-10T13:55:19Z

[-- Attachment #1: Type: text/plain, Size: 29843 bytes --]

Hello

Here is the latest OCaml Weekly News, for the week of September 03 to
10, 2024.

Table of Contents
─────────────────

Oxidizing OCaml — an update
Toy Autograd Engine in OCaml with Apple Accelerate Backend
New release of cppo, with multi-line macros and higher-order macros
OCamlPro's contributions to the 2024 ICFP in Milan
Flambda2 Ep. 3: Speculative Inlining, by OCamlPro
Frustrating Interactions with the OCaml Ecosystem while developing a Synthesizer Library
Cmdlang - Yet Another CLI Library (well, not really)
zarr v0.1.0
Brr 0.0.7
Ocsigen Server 6.0.0
dream-html and pure-html
Advanced Code Navigation coming to OCaml-LSP
Other OCaml News
Old CWN

Oxidizing OCaml — an update
═══════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-oxidizing-ocaml-an-update/15237/1>

Diana Kalinichenko announced
────────────────────────────

Hi everyone! Last year, we made a series of blogposts describing our
plans to introduce Rust-like type system features to OCaml (see
[here]). Now, we are sharing updates on everything we've done since
last year for ICFP 2024. Please read our [blogpost] and check out our
compiler extensions at our [GitHub]!

[here]
<https://discuss.ocaml.org/t/oxidizing-ocaml-and-a-new-opam-switch/12942>

[blogpost] <https://blog.janestreet.com/icfp-2024-index/>

[GitHub]
<https://github.com/janestreet/opam-repository/tree/with-extensions>

Toy Autograd Engine in OCaml with Apple Accelerate Backend
══════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/toy-autograd-engine-in-ocaml-with-apple-accelerate-backend/15239/1>

John Jewell announced
─────────────────────

I have been venturing to learn a new language and I landed on OCaml
after hearing a few interesting talks from Jane Street. I just made
public a toy autograd engine in OCaml with an Apple Accelerate backend
if anyone is interested:

<https://github.com/jewelltaylor/camlgrad>

I would really appreciate any feedback in terms of the OCaml code that
I wrote so that I can improve. If anyone is willing to quickly take a
look it would mean a lot :slight_smile:

New release of cppo, with multi-line macros and higher-order macros
═══════════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-new-release-of-cppo-with-multi-line-macros-and-higher-order-macros/15241/1>

François Pottier announced
──────────────────────────

It is my pleasure to announce a new release of cppo (v1.7.0) with two
new features.

⁃ The new syntax `#def ... #enddef' allows a macro definition to span
several lines, without backslashes. This syntax allows macro
definitions to be nested.
┌────
│ #def repeat_until(action,condition)
│ action;
│ while not (condition) do
│ action
│ done
│ #enddef
└────

⁃ A parameterized macro can take a parameterized macro as a parameter:
this is a higher-order macro.
┌────
│ #define TWICE(e) (e + e)
│ #define APPLY(F : [.], e) (let x = (e) in F(x))
│ let forty_two =
│ APPLY(TWICE,1+2+3+4+5+6)
└────

For more details, please see the [documentation].

[documentation]
<https://github.com/ocaml-community/cppo/?tab=readme-ov-file#multi-line-macros-and-nested-macros>

OCamlPro's contributions to the 2024 ICFP in Milan
══════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ocamlpros-contributions-to-the-2024-icfp-in-milan/15244/1>

OCamlPro announced
──────────────────

Today, a quick head's up about our contributions to this year's
International Conference on Functional Programming which is unraveling
right now in Milan!

This year, our team presents two topics:
• ["Snapshottable Stores"]: A generic and efficient data structure for
the implementation of backtracking algorithms, used particularly in
automatic theorem provers and type checkers. This implementation in
OCaml will soon be available on opam.

• [A presentation on opam], detailing the contents of the latest major
release 2.2, which was released in July, as well as how the opam
team operates.

Be sure to checkout [the event], there are plenty of great
presentations and video replays!

Until next time, which will be sooner than later with another one of
our [Flambda2 Snippets],

Kind regards, The OCamlPro Team

["Snapshottable Stores"]
<https://icfp24.sigplan.org/details/icfp-2024-papers/14/Snapshottable-Stores>

[A presentation on opam]
<https://icfp24.sigplan.org/details/ocaml-2024-papers/10/Opam-2-2-and-beyond>

[the event]
<https://web.cvent.com/event/728be387-4e89-4930-a4e4-51f9d1d6209e/summary>

[Flambda2 Snippets]
<https://ocamlpro.com/blog/2024_03_18_the_flambda2_snippets_0/>

Flambda2 Ep. 3: Speculative Inlining, by OCamlPro
═════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/blog-flambda2-ep-3-speculative-inlining-by-ocamlpro/15250/1>

OCamlPro announced
──────────────────

As promised in our [previous post] about OCamlPro's contributions to
this year's International Conference of Functional Programming, we
back again with a new entry in our [Flambda2 Snippet blog series]!

[Flambda2 Ep. 3: Speculative Inlining] covers inlining in general as
well as how our compiler handles it. We go in detail about how
`Speculative Inlining' allows more significant optimisations to take
place.

This blog entry is key for a smooth read of our next article which
will cover `Upwards and Downwards Traversals' in Flambda2.

Happy to say that it's already quite far down the release pipeline!

[previous post]
<https://discuss.ocaml.org/t/ocamlpros-contributions-to-the-2024-icfp-in-milan/15244>

[Flambda2 Snippet blog series]
<https://ocamlpro.com/blog/2024_03_18_the_flambda2_snippets_0/#listing>

[Flambda2 Ep. 3: Speculative Inlining]
<https://ocamlpro.com/blog/2024_08_09_the_flambda2_snippets_3/>

Frustrating Interactions with the OCaml Ecosystem while developing a Synthesizer Library
════════════════════════════════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/blog-frustrating-interactions-with-the-ocaml-ecosystem-while-developing-a-synthesizer-library/15253/1>

Steve Sherratt announced
────────────────────────

<https://www.gridbugs.org/frustrating-interactions-with-the-ocaml-ecosystem-while-developing-a-synthesizer-library/>

Last year I made a synthesizer library in OCaml and had some struggles
using Dune and Opam, and also ran into several issues with
libraries. I wrote a blog post about all the problems I encountered.

Cmdlang - Yet Another CLI Library (well, not really)
════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/cmdlang-yet-another-cli-library-well-not-really/15258/1>

Mathieu Barbin announced
────────────────────────

I hope you had a nice summer! Mine took an unexpected turn when,
roughly at the same time, I wrote my first `cmdliner' subcommand and
heard about `climate' for the first time. My experience with OCaml CLI
so far had been centered around `core.command'.

When I read climate's [terminology] section and how it defines
`Terms', `Arguments', and `Parameters', something clicked. Seeing how
`climate''s API managed to make positional and named arguments fit so
nicely together, I thought: "Wow, for the first time, it seems I'll be
able to write a CLI spec on a whiteboard without referring to some
code I never seem to get right (I am looking at you, `core.command''s
anonymous arguments)."

I got quite excited and thought: "Can I switch to `climate' today?"
But reality checked: it's not on opam yet, still under construction,
I'm not sure what the community will do, etc.

Implementing my own engine for an API resembling `climate' felt like a
wasted effort, knowing about the work happening in `climate'. Still,
having a `'a Param.t', `'a Arg.t', and `'a Command.t' type that I
would get to know and love felt too good to pass up.

I stared at the `climate' types for a while, and filled with happy
thoughts about a bright CLI future, it occurred to me: can I use an
API like `climate' but compile it down to existing libraries such as
`cmdliner' or `core.command'? (and `climate' too!). I wrote down the
following types:

[terminology]
<https://github.com/gridbugs/climate?tab=readme-ov-file#terminology>

Climate
╌╌╌╌╌╌╌

┌────
│ 'a Param.t -> 'a Climate.Arg_parser.conv
│ 'a Ast.Arg.t -> 'a Climate.Arg_parser.t
│ 'a Command.t -> 'a Climate.Command.t
└────

Cmdliner
╌╌╌╌╌╌╌╌

┌────
│ 'a Param.t -> 'a Cmdliner.Arg.conv
│ 'a Arg.t -> 'a Cmdliner.Term.t
│ 'a Command.t -> 'a Cmdliner.Cmd.t
└────

core.command
╌╌╌╌╌╌╌╌╌╌╌╌

┌────
│ 'a Param.t -> 'a core.Command.Arg_type.t
│ 'a Arg.t -> 'a core.Command.Param.t
│ unit Command.t -> core.Command.t
└────

… which I interpreted as stating the following theorem:

There exists an abstraction to encode OCaml CLIs that
lives in the intersection of what's expressible in other
well established libraries.

"One EDSL to command them all," so to speak. I couldn't resist the
temptation to build actual terms for these types. That gave birth to
[cmdlang].

As a test, I switched one of my projects to `cmdlang', with `cmdliner'
as a backend. I liked the [changes] I made in the process. The 1-line
[bin/main.ml] is now the only place that specifies which backend I
want to use; the rest of the code is programmed solely against the
`cmdlang' API. This means I'll be able to easily experiment with
compiling down to `climate' in the future.

I am not against the multiplicity of solutions in general, but I tend
to feel uneasy when incompatible libraries emerge, partitioning the
ecosystem. As a community, we know too many examples of this. In this
instance, I want to call the `core.command' vs `cmdliner' situation a
… cli-vage.

I don't see my work on `cmdlang' as competing with these other
libraries. Quite the contrary, it makes it easier for me to experiment
with them without much changes while exploring the subject of CLI in
general. Also, as a library author, if you wish to expose CLI helpers
to your users, a library like `cmdlang' will give you a pleasant way
to do so, as you can express your helpers with it, knowing your users
will have the choice to translate them to the backend of their choice.

Before writing this post, I had a very pleasant chat with @gridbugs. I
want to make it clear that I do not think `cmdlang' is competing with
`climate' either. I think `climate' is a very promising library and I
believe it will, in due time, deliver auto-completion to many - this
has been a highly anticipated feature within the community. I wish to
dedicate the initial work that I did on `cmdlang' to @gridbugs due to
the impactful influence climate had on my work, and how it helped me
improve my general understanding of declarative CLI libraries.

These are very early days for `cmdlang'. There are still areas I am
fuzzy on, and I haven't really validated the whole design yet. I have
put some thoughts in this [Future Plans] page. One thing that I did
not initially include there would be to explore the feasibility of
writing a mini-compiler for `cmdlang' targeting `stdlib.arg' as a
runner. I am not sure how much you'd end up restricting `cmdlang' for
this to work. I thought that'd be a fun project to tackle at a future
point, as it would make a nice addition to the overall architecture of
the project.

I'd welcome your input to help me shape the future of `cmdlang' if you
have an interest in this project.

Thanks for reading!

[cmdlang] <https://github.com/mbarbin/cmdlang>

[changes] <https://github.com/mbarbin/bopkit/pull/14>

[bin/main.ml] <https://github.com/mbarbin/bopkit/blob/main/bin/main.ml>

[Future Plans]
<https://mbarbin.github.io/cmdlang/docs/explanation/future_plans/>

zarr v0.1.0
═══════════

Archive: <https://discuss.ocaml.org/t/ann-zarr-v0-1-0/15259/1>

zoj613 announced
────────────────

Hi everyone, I'd like to announce the first release of `zarr', an
Ocaml implementation of the [Zarr version 3 storage format
specification] for chunked & compressed multi-dimensional arrays,
designed for use in parallel computing.

<https://zarr-specs.readthedocs.io/en/latest/_images/terminology-hierarchy.excalidraw.png>

[Zarr version 3 storage format specification]
<https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html>

why?
╌╌╌╌

The project was mainly inspired by the lack of functional programming
language implementations of this specification as shown in this
[implementations table]. Since I have been learning OCaml these past
few months I figured I'd take on the challenge of producing the first
functional programming implementation of Zarr, and it was a great
learning experience!

[implementations table] <https://zarr.dev/implementations/>

Features
╌╌╌╌╌╌╌╌

• Supports creating n-dimensional Zarr arrays and chunking them along
any dimension.
• Compress array chunks using a variety of supported compression
codecs.
• Supports indexing operations to read/write views of a Zarr array.
• Supports storing arrays in-memory or the local filesystem. It is
also extensible, allowing users to easily create and use their own
custom storage backends. See the example implementing a [Zip file
store] for more details.
• Supports both synchronous and concurrent I/O via `Lwt' and `Eio'.
• Leverages the strong type system of Ocaml to create a type-safe API;
making it impossible to create, read or write malformed arrays.
• Supports organizing arrays into hierarchies using [Groups].

[Zip file store]
<https://github.com/zoj613/zarr-ml/blob/main/examples/inmemory_zipstore.ml>

[Groups]
<https://zarr-specs.readthedocs.io/en/latest/v3/core/v3.0.html#group>

Example
╌╌╌╌╌╌╌

Below is a demo of the library's API for creating, reading and writing
to a Zarr hierarchy.
┌────
│ open Zarr
│ open Zarr.Metadata
│ open Zarr.Node
│ open Zarr.Codecs
│ open Zarr.Indexing
│ open Zarr_sync.Storage
│ (* opens infix operators >>= and >>| for monadic bind & map *)
│ open FilesytemStore.Deferred.Infix
│
│ let store = FilesystemStore.create "testdata.zarr" in
│ let group_node = GroupNode.of_path "/some/group" in
│ FilesystemStore.create_group store group_node;
│ let array_node = ArrayNode.(group_node / "name");;
│ (* creates an array with char data type and fill value '?' *)
│ FilesystemStore.create_array
│ ~codecs:[`Transpose [|2; 0; 1|]; `Bytes BE; `Gzip L2]
│ ~shape:[|100; 100; 50|]
│ ~chunks:[|10; 15; 20|]
│ Ndarray.Char
│ '?'
│ array_node
│ store;
│ let slice = [|R [|0; 20|]; I 10; R [||]|] in
│ let x = FilesystemStore.read_array store array_node slice Ndarray.Char in
│ (* Do some computation on the array slice *)
│ let x' = Zarr.Ndarray.map (fun _ -> Random.int 256 |> Char.chr) x in
│ FilesystemStore.write_array store array_node slice x';
│ let y = FilesystemStore.read_array store array_node slice Ndarray.Char in
│ assert (Ndarray.equal x' y);
└────

Installation
╌╌╌╌╌╌╌╌╌╌╌╌

The library comes in several flavors depending on the synchronous /
asynchronous backend of choice. To install the synchronous API, use
┌────
│ $ opam install zarr-sync
└────

To install zarr with an asynchronous API powered by `Lwt' or `Eio',
use
┌────
│ $ opam install zarr-lwt
│ $ opam install zarr-eio
└────

The documentation can be found [here] and the source code [there]

I'm happy to answer any questions regarding the library and more than
welcome suggestions for improvements (especially performance!), issue
reports as well as PR's.

[here] <https://zoj613.github.io/zarr-ml/>

[there] <https://github.com/zoj613/zarr-ml>

Brr 0.0.7
═════════

Archive: <https://discuss.ocaml.org/t/ann-brr-0-0-7/15263/1>

Daniel Bünzli announced
───────────────────────

There'a new release of [Brr], an ISC licenced toolkit for programming
browsers with the `js_of_ocaml' compiler.

This release has some changes to support work being done for
`wasm_of_ocaml'; thanks to @vouillon for his patches. There are also
other small fixes and additions, consult the [release notes] for the
details and thanks to all the contributors.

A big thanks to my [donators] for supporting my work. I welcome the
(not so[^1]) new donator [Tarides].

[Home page], [Docs and manuals] or `odig doc brr'

Install: `opam install brr' ([PR])

Best,

Daniel

[^1]: Tarides has been /generously/ donating for my work from the
onset but used to do it via the [Mirage] organisation.

[Brr] <https://erratique.ch/software/brr>

[release notes]
<https://github.com/dbuenzli/brr/blob/f9f4de5c9385ceb80164c043943e3a2d65e577c3/CHANGES.md#v007-2024-09-09-zagreb>

[donators] <https://github.com/sponsors/dbuenzli>

[Tarides] <https://tarides.com/>

[Home page] <https://erratique.ch/software/brr>

[Docs and manuals] <https://erratique.ch/software/brr/doc/>

[PR] <https://github.com/ocaml/opam-repository/pull/26517>

[Mirage] <https://github.com/mirage>

Ocsigen Server 6.0.0
════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-ocsigen-server-6-0-0/15265/1>

Vincent Balat announced
───────────────────────

We're delighted to announce a major new version of Ocsigen Server!
This version 6.0.0 focuses on the use of Ocsigen Server as a library,
without any configuration file, which is now much easier and brings
the exact same features as the executable.

*Example of use:*

To add a Web server to your OCaml program, serving static files from
directory `static`:
┌────
│ let _ = Ocsigen_server.start
│ [ Ocsigen_server.host [Staticmod.run ~dir:"static" ()]]
└────

Install:

┌────
│ opam install ocsigenserver
└────

Example of Dune file for this program:
┌────
│ (executable
│ (public_name myproject)
│ (name main)
│ (libraries
│ main
│ ocsigenserver
│ ocsigenserver.ext.staticmod))
└────

Compile with:
┌────
│ dune build
└────

Ocsigen Server can of course still be used as an executable taking its
configuration from a file. This allows for non OCaml developers to use
it and make their own configurations. It also makes it possible to
distribute a binary version of your Web applications.

Ocsigen Server is build in modular and extensible way. The default
opam packages comes with several extensions. In the example above, we
are using Staticmod for serving static files. Other extensions makes
it possible for example to configure redirections, to control the
access to some sub-directory, to use a reverse proxy, to rewrite the
request, compress the output etc.

The programming interface follows exactly the structure of the
configuration file: instructions are tried in order until one
generates a result, then some other instructions can be used to change
the result (like compressing it or adding some headers).

Here is a more complex example of configuration:
┌────
│ let _ =
│ Ocsigen_server.start
│ ~ports:[`All, 8080]
│ ~command_pipe:"local/var/run/mysite-cmd"
│ ~logdir:"local/var/log/mysite"
│ ~datadir:"local/var/data/mysite"
│ ~default_charset:(Some "utf-8")
│ [ Ocsigen_server.host
│ ~regexp:"mydomain.com"
│ [ Ocsigen_server.site ["subsite"]
│ [ Accesscontrol.(
│ if_
│ (and_
│ [ ip "122.122.122.122"
│ ; header ~name:"user-agent" ~regexp:".*FooBar.*"
│ ; method_ `POST ])
│ [forbidden] [])
│ ; Authbasic.run ~realm:"myrealm"
│ ~auth:(fun _u p -> Lwt.return (p = "toto"))
│ ()
│ ; Staticmod.run ~dir:"local/var/www/otherdir" () ]
│ ; Ocsigen_server.site ["othersubsite"]
│ [ Revproxy.run
│ ~redirection:
│ (Revproxy.create_redirection ~full_url:false ~regexp:"(.*)"
│ ~keephost:true "http://localhost:8888/\\1")
│ () ]
│ ; Redirectmod.run
│ ~redirection:
│ (Redirectmod.create_redirection ~full_url:false ~regexp:"old(.*)"
│ "new\\1")
│ ()
│ ; Staticmod.run ~dir:"local/var/www/staticdir" ()
│ ; Cors.run ~max_age:86400 ~credentials:true ~methods:[`POST; `GET; `HEAD]
│ ~exposed_headers:
│ [ "x-eliom-application"
│ ; "x-eliom-location"
│ ; "x-eliom-set-process-cookies"
│ ; "x-eliom-set-cookie-substitutes" ]
│ ()
│ ; Deflatemod.run
│ ~mode:
│ (`Only
│ [ `Type (Some "text", Some "html")
│ ; `Type (Some "text", Some "javascript")
│ ; `Type (Some "text", Some "css")
│ ; `Type (Some "application", Some "javascript")
│ ; `Type (Some "application", Some "x-javascript")
│ ; `Type (Some "application", Some "xhtml+xml")
│ ; `Type (Some "image", Some "svg+xml")
│ ; `Type (Some "application", Some "x-eliom") ])
│ () ] ]
└────

In this example, the server defines one virtual host for domain
`mydomain.com'. It will first check whether it is a request for
directory `subsite/', and if yes, will reject the request with 403
Forbidden if it is a POST request coming from user-agent `FooBar' at
IP 122.122.122.122. If not, it will ask for a password before serving
files from directory `local/var/www/otherdir'. Then we define another
subsite `othersubsite' for which the requests will be transfered to
another Web server running locally on port 8888, then rewrite the
answer location header accordingly. Then, if the page is still not
generated, the server will send a redirection if URLs starts with
"old". Otherwise, it will try to serve files from directory
`local/var/www/staticdir'. If the page has still not been found, a
`404 Not found' will be sent, otherwise, some CORS headers will be
added, and the result will be compressed before being sent.

Compile this example with the following dune file:
┌────
│ (executable
│ (public_name myserver)
│ (name main)
│ (libraries
│ ocsigenserver
│ ocsigenserver.ext.staticmod
│ ocsigenserver.ext.authbasic
│ ocsigenserver.ext.extendconfiguration
│ ocsigenserver.ext.outputfilter
│ ocsigenserver.ext.cors
│ ocsigenserver.ext.accesscontrol
│ ocsigenserver.ext.deflatemod
│ ocsigenserver.ext.redirectmod
│ ocsigenserver.ext.revproxy
│ ))
└────

Eliom and Ocsigen Start have also been updated for being used without
configuration file and will be released very soon.

dream-html and pure-html
════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-dream-html-pure-html-3-5-2/14808/4>

Yawar Amin announced
────────────────────

[ANN] dream-html & pure-html 3.6.1, 3.6.2

A double announcement:

3.6.1: when in XML rendering mode, correctly render empty-value
attributes as having an empty string value. Thanks to @jonsterling !

3.6.2: automatically switch to XML rendering mode when rendering SVG
and MathML tags inside HTML rendering mode.

Advanced Code Navigation coming to OCaml-LSP
════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-advanced-code-navigation-coming-to-ocaml-lsp/15266/1>

PizieDust announced
───────────────────

Jump to Target
╌╌╌╌╌╌╌╌╌╌╌╌╌╌

Currently, the standard LSP protocol only allows for generalized code
navigation (`goto definition`, `goto declaration`, `goto
implementation`, `goto type-definition`), which is not very useful
when it comes to precise movements.

Coming to OCaml-lsp soon will be the ability to jump from one point in
your code to another based on [Merlin's Jump] command.

Implementing this functionality took a bit of thinking as we wanted a
solution that works for all supported editors (Vscode, Emacs and Vim)
without any additional specific client implementations. We used a
combination of call actions plus the LSP showDocumentRequest to move
the cursor to the interesting position.

The call actions display are contextual and will display only if it's
relevant to the code under the cursor.

Here is a demo in VSCode.

<https://global.discourse-cdn.com/business7/uploads/ocaml/original/2X/6/618bfd77db1a89256eeeaf69b6d3817dbfdd8dc0.gif>

[Merlin's Jump]
<https://github.com/ocaml/merlin/blob/main/doc/dev/PROTOCOL.md#jump--target-string--position-position>

Other OCaml News
════════════════

From the ocaml.org blog
───────────────────────

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

• [Outreachy May 2024 Demo]
• [Frama-Clang v0.0.16 for Frama-C 29.0 Copper]
• [Easy Debugging for OCaml With LLDB]
• [Getting Specific: Announcing the Gospel and Ortac Projects]
• [Upcoming OCaml Events (Sep 2024 and onwards)]

[the ocaml.org blog] <https://ocaml.org/blog/>

[Outreachy May 2024 Demo]
<https://watch.ocaml.org/w/peT3MdWjS1BYYMbowEJ1gv>

[Frama-Clang v0.0.16 for Frama-C 29.0 Copper]
<https://frama-c.com/html/news.html#2024-09-05>

[Easy Debugging for OCaml With LLDB]
<https://tarides.com/blog/2024-09-05-easy-debugging-for-ocaml-with-lldb>

[Getting Specific: Announcing the Gospel and Ortac Projects]
<https://tarides.com/blog/2024-09-03-getting-specific-announcing-the-gospel-and-ortac-projects>

[Upcoming OCaml Events (Sep 2024 and onwards)]
<https://ocaml.org/events>

Old CWN
═══════

If you happen to miss a CWN, you can [send me a message] and I'll mail
it to you, or go take a look at [the archive] or the [RSS feed of the
archives].

If you also wish to receive it every week by mail, you may subscribe
to the [caml-list].

[Alan Schmitt]

[send me a message] <mailto:alan.schmitt@polytechnique.org>

[the archive] <https://alan.petitepomme.net/cwn/>

[RSS feed of the archives] <https://alan.petitepomme.net/cwn/cwn.rss>

[caml-list] <https://sympa.inria.fr/sympa/info/caml-list>

[Alan Schmitt] <https://alan.petitepomme.net/>

[-- Attachment #2: Type: text/html, Size: 53773 bytes --]