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

Alan Schmitt
2024-10-08T10:56:44Z

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

Hello

Here is the latest OCaml Weekly News, for the week of October 01 to 08,
2024.

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

Releases of fpath-sexplib0, fpath-base, loc, file-rewriter, sexps-rewriter and provider
Build a project without Stdlib
obatcher: Framework for building efficient concurrent services
DBLP query program and library
cudajit: Bindings to the `cuda' and `nvrtc' libraries
YOCaml, a framework for static site generator
oepub 0.1.0 : A library to parse epub files
ppx_deriving_router — type safe routing for Dream and Melange
Mica, a PPX that automates differential testing for OCaml modules
Simplified Android cross-compiler with DkML
Other OCaml News
Old CWN

Releases of fpath-sexplib0, fpath-base, loc, file-rewriter, sexps-rewriter and provider
═══════════════════════════════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/releases-of-fpath-sexplib0-fpath-base-loc-file-rewriter-sexps-rewriter-and-provider/15364/1>

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

I wanted to announce the initial release of 6 utility packages to the
opam-repository. They are dependencies to some other ongoing projects
I have, perhaps some will find them useful.

These are very early days for this software. Please feel welcome to
opening issues or discussions tickets if you are inclined.

Thank you @mseri , @avsm & @shonfeder for your help in making these
libraries available!

Below you'll find short descriptions with links to the packages home
pages. Thank you!

[Fpath_sexplib0] only depends on `fpath' and `sexplib0'. It defines a
single module, `Fpath_sexplib0', which is designed to be opened to
shadow the `Fpath' module to add small helpers and a `sexp_of'
serializer to it. The package also introduces three new modules to the
scope: `Fpart', `Absolute_path' and `Relative_path' to increase
type-safety when manipulating paths that are known to be relative or
absolute.

[Fpath_base] further extends `fpath-sexplib0' and adds a dependency on
base. It is designed to be compatible with Base-style containers such
as `Map', `Set', `Hashtbl', `Hash_set'.

[Loc] is an OCaml library to manipulate code locations, which are
ranges of lexing positions from a parsed file.

[File_rewriter] is an OCaml library for applying small rewrites to
tweak or refactor your files. It provides a convenient interface to
apply surgical textual substitutions on the fly, while navigating the
contents of a file through an abstract representation containing code
locations.

[Sexps_rewriter] is a specialized version of the `file-rewriter'
library dedicated to rewriting sexp files, such as dune config files.

[Provider] is an OCaml library for creating Traits and Interfaces. It
allows you to define the functionality needed by a library without
committing to a specific implementation - in essence : dynamic
dispatch. Provider is a pattern featured in the `Eio' project
(`Eio.Resource'). I wanted to make it reusable in other projects - in
particular I am currently using it as the parametrization story of
`vcs'. This package had already been available for a little while
already but was still unannounced.

[Fpath_sexplib0] <https://github.com/mbarbin/fpath-base>

[Fpath_base] <https://github.com/mbarbin/fpath-base>

[Loc] <https://github.com/mbarbin/loc>

[File_rewriter] <https://github.com/mbarbin/file-rewriter>

[Sexps_rewriter] <https://github.com/mbarbin/file-rewriter>

[Provider] <https://github.com/mbarbin/provider>

Build a project without Stdlib
══════════════════════════════

Archive:
<https://discuss.ocaml.org/t/build-a-project-without-stdlib/15374/1>

Mikhail announced
─────────────────

I decided to experiment with compiling a project without the standard
library. Why? I don't know. But I could save ~50K. Just sharing my
note about it.

You can find an example in my [repository].

I found the `-nostdlib' and `-nopervasives' (undocumented) flags and
after a lot of trying I was able to do what I wanted. It doesn't
disable absolutely everything (lists and other types like `option' are
available).

┌────
│ (flags
│ :standard
│ -nostdlib
│ -nopervasives
│ ; add runtime
│ -cclib
│ -lasmrun
│ -ccopt
│ "-L %{ocaml_where}"
│ -ccopt
│ "-lm -ldl")
└────

┌────
│ (* stdlib.ml *)
│ external print_endline : string -> unit = "caml_print_endline" [@@noalloc]
│
│ (* main.ml *)
│ open Stdlib
│ let () = print_endline "hello from my stdlib"
└────

Hello World program:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with Stdlib without Stdlib
─────────────────────────────────────
*size* 349K 302K
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

[repository] <https://github.com/dx3mod/ocaml-without-stdlib>

obatcher: Framework for building efficient concurrent services
══════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-obatcher-framework-for-building-efficient-concurrent-services/15384/1>

Lee Koon Wen announced
──────────────────────

Hot on the heels of the paper [/"Concurrent Data Structures Made
Easy"/] appearing at [OOPSLA 2024] on the 24th October, I'm pleased to
announce release of *obatcher* - a _picos_ compatible library for
implementing efficient batched services in OCaml.

*obatcher* proposes a *new* way to approach the design and
implementation of concurrent services. It's key benefits are:

• Incremental optimization and parallelism of services
• Easy to control and reason about concurrency
• Retains atomic-style interface with your services while batching
happens implicitly
• Thread-safety for cheap!

Available on opam today, install with
┌────
│ opam install obatcher
└────

For more details, check out the source and README on GitHub:
[obatcher].

Feedback, contributions, and discussions are welcome!

[/"Concurrent Data Structures Made Easy"/]
<https://koonwen.github.io/assets/pdf/concurrent-structures-made-easy.pdf>

[OOPSLA 2024]
<https://2024.splashcon.org/details/splash-2024-oopsla/118/Concurrent-Data-Structures-Made-Easy>

[obatcher] <https://github.com/koonwen/obatcher>

DBLP query program and library
══════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-dblp-query-program-and-library/15385/1>

Samuel Mimram announced
───────────────────────

I am happy to announce the first realease of [ocaml-dblp], which
provides both a program and a library to query the [DBLP]
bibliographic database. In practice, it is mostly useful for
retrieving bibtex entries with commands such as

┌────
│ dblp bibtex girard locus solum
└────

which will spit out

┌────
│ @article{DBLP:journals/mscs/Girard01,
│ author = {Jean{-}Yves Girard},
│ title = {Locus Solum: From the rules of logic to the logic of rules},
│ journal = {Math. Struct. Comput. Sci.},
│ volume = {11},
│ number = {3},
│ pages = {301--506},
│ year = {2001},
│ url = {https://doi.org/10.1017/S096012950100336X},
│ doi = {10.1017/S096012950100336X},
│ timestamp = {Wed, 01 Apr 2020 08:48:47 +0200},
│ biburl = {https://dblp.org/rec/journals/mscs/Girard01.bib},
│ bibsource = {dblp computer science bibliography, https://dblp.org}
│ }
└────

(or, even better, use `dblp bib' to directly add this at the end of
the `.bib' file in the current directory).

It might still need some polishing, feel free to reach out if you
encounter some problems.

[ocaml-dblp] <https://github.com/smimram/ocaml-dblp>

[DBLP] <https://dblp.org/>

cudajit: Bindings to the `cuda' and `nvrtc' libraries
═════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-cudajit-bindings-to-the-cuda-and-nvrtc-libraries/15010/2>

Lukasz Stafiniak announced
──────────────────────────

cudajit 0.5.0 is now available in the opam repository. It's organized
into [modules], and it adds support for CUDA events.

[modules]
<https://lukstafi.github.io/ocaml-cudajit/cudajit/Cudajit/index.html>

YOCaml, a framework for static site generator
═════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-yocaml-a-framework-for-static-site-generator/15393/1>

Xavier Van de Woestyne announced
────────────────────────────────

:wave: Hello everyone! We, the YOCaml development team, are very
pleased to announce the release of [version 2], freshly merged into
[opam-repository] :champagne:!

*YOCaml is a framework for describing static site generators* (a very
small applicative build-system whose API is tailor-made for creating
web pages ) and its internal model is very similar to [Hakyll] (the
3th version), another Haskell framework. (a presentation was given to
the OCaml user Group in Paris and you can find the video, [in French,
here]).

[version 2] <https://github.com/xhtmlboi/yocaml/releases/tag/v2.0.0>

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

[Hakyll] <https://jaspervdj.be/hakyll/>

[in French, here]
<https://www.irill.org/videos/OUPS/2023-01/xavier-van-de-woestyne.html>

Changes with 1.0.0
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

Historically, YOCaml was written very, very quickly to give examples
of slightly exotic uses of the library [Preface]. Due to its
experimental nature, the API was a bit laborious, but we did find some
users! We took advantage of the redesign to stop relying on Preface
(and yes, YOCaml was already more widely used than Preface), move to
OCaml 5.x and take advantage of _user-defined-effects_ and support
dynamic dependencies. In other words, YOCaml `2.0.0' is not at all
compatible with version 1…

[Preface] <https://github.com/xvw/preface>

Plugins and runtimes
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

The aim of YOCaml is to be very generic and to allow users to bring
their own dependencies, but we've taken the opportunity to release it
with several plugins and runtimes so that it can be used directly.

◊ Runtimes

A Runtime is an ‘execution context’ and generally exposes the
primitive used to execute a YOCaml program. YOCaml 2 is bundled with 3
Runtimes:

• *Yocaml_unix*: the default runtime, whose preview server is
implemented on top of the brand new [httpcats]!

• *Yocaml_eio*: a runtime iso to Unix but based on [eio] and whose
preview server is described by [cohttp_eio].

• *Yocaml_git*: a parameterised runtime for generating a site directly
in a git repository, which can be served, for example, by a
[Mirage] ([unipi]), very well documented in this [excellent
article] by @dinosaure!

[httpcats] <https://github.com/robur-coop/httpcats>

[eio] <https://github.com/ocaml-multicore/eio>

[cohttp_eio] <https://github.com/mirage/ocaml-cohttp>

[Mirage] <https://mirage.io/>

[unipi] <https://github.com/robur-coop/unipi>

[excellent article] <https://blog.osau.re/articles/blog_requiem.html>

◊ Plugins

• *Yocaml_cmarkit* provides a convenient API (via YOCaml) for
converting Markdown files to HTML via the excellent [cmarkit]
library.

• *Yocaml_omd* provides a convenient API (via YOCaml) for converting
Markdown files to HTML via the excellent [OMD] library (but we
recommend `yocaml_cmarkit').

• *yocaml_yaml* provides a convenient API (via YOCaml) for reading
Yaml via the excellent library [ocaml-yaml]

• *yocaml_otoml* provides a convenient API (for YOCaml) for reading
TOML via the excellent library [Otoml]

• *yocaml_mustache* provides a convenient API (via YOCaml) for using
[Mustache] as a template language via the excellent library
[ocaml-mustache]

• *yocaml_jingoo* provides a convenient API (via YOCaml) for using
[Jingoo] as a template language via the excellent library [jingoo]

• *yocaml_syndication* that gives tool to generate feeds
([Atom](<https://en.wikipedia.org/wiki/Atom_(web_standard)>), [RSS]
1 and 2 and [OPML]). The library is inspired by [Syndic] but does
not depend directly on it.

[cmarkit] <https://github.com/dbuenzli/cmarkit>

[OMD] <https://github.com/ocaml/omd>

[ocaml-yaml] <https://github.com/avsm/ocaml-yaml>

[Otoml] <https://github.com/dmbaturin/otoml>

[Mustache] <https://mustache.github.io/>

[ocaml-mustache] <https://github.com/rgrinberg/ocaml-mustache>

[Jingoo] <http://tategakibunko.github.io/jingoo/>

[jingoo] <https://github.com/tategakibunko/jingoo>

[RSS] <https://en.wikipedia.org/wiki/RSS>

[OPML] <https://opml.org/>

[Syndic] <https://github.com/Cumulus/Syndic>

A final word
╌╌╌╌╌╌╌╌╌╌╌╌

YOCaml 2 was mainly written by [xhtmlboi], helped by [gr-im], [mspwn]
and [dinosaure] with occasional support from [maiste]. It has already
been used experimentally in a number of small projects:

• [Ring.muhokama] a very small webring - [sources]
• [Maiste.fr] - [sources]
• [gr-im.github.io] - [sources]

You will also find extensively documented examples in the [examples]
directory.

To conclude, we find (not very objectively) that YOCaml is a lot of
fun to use, and it's very cool to make your site using as much OCaml
as possible.

Happy Hacking!

• [Yocaml on OPAM]
• [Dev repository]

[xhtmlboi] <https://github.com/xhtmlboi>

[gr-im] <https://github.com/gr-im>

[mspwn] <https://github.com/mspwn>

[dinosaure] <https://github.com/dinosaure>

[maiste] <https://github.com/maiste>

[Ring.muhokama] <https://ring.muhokama.fun>

[sources] <https://github.com/muhokama/ring>

[Maiste.fr] <https://maiste.fr>

[sources] <https://github.com/maiste/maiste.fr>

[gr-im.github.io] <https://gr-im.github.io>

[sources] <https://github.com/gr-im/site>

[examples] <https://github.com/xhtmlboi/yocaml/tree/main/examples>

[Yocaml on OPAM] <https://ocaml.org/p/yocaml/latest>

[Dev repository] <https://github.com/xhtmlboi/yocaml>

oepub 0.1.0 : A library to parse epub files
═══════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-oepub-0-1-0-a-library-to-parse-epub-files/15394/1>

EruEri announced
────────────────

I humbly announce oepub a small library to parse epub files and to
some extend create a list of chapters from the epub archive.

You can find the repository at [Codeberg - Oepub]

[Codeberg - Oepub] <https://codeberg.org/EruEri/oepub>

ppx_deriving_router — type safe routing for Dream and Melange
═════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-ppx-deriving-router-type-safe-routing-for-dream-and-melange/15401/1>

Andrey Popp announced
─────────────────────

It's my pleasure to announce a new ppx for deriving [Dream] routers
based on variant type declarations, [ppx_deriving_router].

A small example. First we define routes (the signature showcases the
generated code):
┌────
│ module Pages : sig
│ ...
│
│ val href : t -> string
│ (** generate URL from the route *)
│
│ val http_method : t -> [ `DELETE | `GET | `POST | `PUT ]
│ (** HTTP method for the route *)
│
│ val handle : (t -> Dream.handler) -> Dream.handler
│ (** create a route handler *)
│ end = struct
│ open Ppx_deriving_router_runtime.Primitives
│
│ type t =
│ | Home [@GET "/"]
│ | About
│ | Hello of { name : string; repeat : int option } [@GET "/hello/:name"]
│ [@@deriving router]
│ end
└────

Then we describe how we handle each route:
┌────
│ let handle =
│ Pages.handle (fun route _req ->
│ match route with
│ | Home -> Dream.respond "Home page!"
│ | About -> Dream.respond "About page!"
│ | Hello { name; repeat } ->
│ let name =
│ match repeat with
│ | Some repeat ->
│ List.init repeat (fun _ -> name) |> String.concat ", "
│ | None -> name
│ in
│ Dream.respond (Printf.sprintf "Hello, %s" name))
│
│ let () = Dream.run ~interface:"127.0.0.1" ~port:8080 handle
└────

Using generated `Pages.href' function we can generate URLs for routes:
┌────
│ let () =
│ assert (Pages.href Home = "/");
│ assert (Pages.href About = "/about");
│ assert (Pages.href (Hello { name = "world"; repeat = None }) = "/hello/world");
│ assert (Pages.href (Hello { name = "world"; repeat = Some 3 }) = "/hello/world?repeat=3")
└────

The URL matching is done by [routes] library.

There's also support for [routes that track their response types] and
the ppx automatically derives JSON encoders and decoders for them (by
using [melange-json.ppx]).

On top of that a [separate ppx is provided] for [Melange] which allows
to construct type safe HTTP clients (route defintions are shared
between server and client).

Happy hacking!

[Dream] <https://aantron.github.io/dream/>

[ppx_deriving_router]
<https://github.com/andreypopp/ppx_deriving_router>

[routes] <https://anuragsoni.github.io/routes/>

[routes that track their response types]
<https://github.com/andreypopp/ppx_deriving_router#routes-with-typed-responses>

[melange-json.ppx]
<https://github.com/melange-community/melange-json?tab=readme-ov-file#ppx-for-melange>

[separate ppx is provided]
<https://github.com/andreypopp/ppx_deriving_router#using-with-melange>

[Melange] <https://melange.re/>

Mica, a PPX that automates differential testing for OCaml modules
═════════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-mica-a-ppx-that-automates-differential-testing-for-ocaml-modules/15406/1>

Ernest Ng announced
───────────────────

I'm delighted to announce the initial release of [Mica], a PPX deriver
that automates differential testing for a pair of OCaml modules
implementing the same signature. Users annotate module signatures with
the directive `[@@deriving mica]', and at compile-time, Mica derives
specialized [property-based testing] (PBT) code that checks if two
modules implementing the signature are observationally
equivalent. (Under the hood, Mica uses Jane Street's
[`Core.Quickcheck'] PBT library.)

Mica was presented at the OCaml Workshop '24 ([paper]) and the ICFP
'23 Student Research Competition ([poster]).

*Note*: Mica is currently a research tool and should not be used in
production code, although contributions are very welcome!

Mica is available on Opam:
┌────
│ opam update
│ opam install ppx_mica
└────
(OCaml 5.1 or newer is required.)

Docs are available [here], and a simple web app demo-ing Mica is
available [here].

[Mica] <https://github.com/ngernest/mica>

[property-based testing] <https://www.youtube.com/watch?v=qmA9qhaECcE>

[`Core.Quickcheck'] <https://blog.janestreet.com/quickcheck-for-core/>

[paper] <https://arxiv.org/abs/2408.14561>

[poster] <https://ngernest.github.io/pdfs/mica_icfp23src_poster.pdf>

[here] <https://ngernest.github.io/mica/ppx_mica/index.html>

[here] <https://ngernest.github.io/mica/demo.html>

Simplified Android cross-compiler with DkML
═══════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-simplified-android-cross-compiler-with-dkml/15407/1>

jbeckford announced
───────────────────

DkML has had a cross-compiler for years, but I have cleaned it up so
that it is much easier to use for Android developers. It *now works
with a regular opam installation in a custom repository*. Also
included are patches to the OCaml compiler to work with Android NDK
21+ (currently Google is at NDK 27).

Try it out if you do Android development … just copy-and-paste the
instructions below … but please read the notes and cautions below. And
if you are still interested in Android development, tell me so I can
decide if I'll merge the packages into the regular opam repository.

Trimmed slightly from the [dkml-compiler Quick Start]:

• Docker container is used below for Windows and macOS users, and
because it is easy to get the Android NDK from CircleCI.
• Apple Silicon does not support 32-bit. The net effect is that Apple
Silicon users cannot cross-compile `android_arm32v7a'.

┌────
│ $ docker run -it --rm cimg/android:2024.10.1-ndk
│
│ # Install opam if you don't have it
│ ~/project$ sudo apt-get update && sudo apt-get install build-essential curl git patch rsync unzip -y
│ ~/project$ echo /usr/local/bin | sudo bash -c "sh <(curl -fsSL https://opam.ocaml.org/install.sh) --version 2.2.1"
│
│ # Initialize opam if you haven't already. No sandboxing is needed in containers.
│ ~/project$ opam init --cli=2.1 --no-setup --bare --disable-sandboxing
│
│ # Two Android options to set. ANDROID_PLATFORM is the minimum API level ("targetSdkVersion" in the Android manifest)
│ ~/project$ opam var --cli=2.1 --global ANDROID_NDK=/home/circleci/android-sdk/ndk/27.1.12297006
│ ~/project$ opam var --cli=2.1 --global ANDROID_PLATFORM=android-34
│
│ # PICK ONE: Android arm64-v8a switch
│ ~/project$ opam switch create android34-ndk27-arm64-v8a --cli=2.1 \
│ --packages dkml-base-compiler,dkml-host-abi-linux_x86_64,dkml-target-abi-android_arm64v8a,ocamlfind,conf-dkml-cross-toolchain \
│ --repos default,diskuv-4d79e732=git+https://github.com/diskuv/diskuv-opam-repository.git#4d79e732
│
│ # PICK ONE: Android armeabi-v7a switch. You will need a 32-bit C/C++ compiler.
│ ~/project$ sudo apt-get install gcc-multilib g++-multilib -y
│ ~/project$ opam switch create android34-ndk27-armeabi-v7a --cli=2.1 \
│ --packages dkml-base-compiler,dkml-host-abi-linux_x86,dkml-target-abi-android_arm32v7a,ocamlfind,conf-dkml-cross-toolchain \
│ --repos default,diskuv-4d79e732=git+https://github.com/diskuv/diskuv-opam-repository.git#4d79e732
│
│ # PICK ONE: Android x86_64 switch
│ ~/project$ opam switch create android34-ndk27-x86_64 --cli=2.1 \
│ --packages dkml-base-compiler,dkml-host-abi-linux_x86_64,dkml-target-abi-android_x86_64,ocamlfind,conf-dkml-cross-toolchain \
│ --repos default,diskuv-4d79e732=git+https://github.com/diskuv/diskuv-opam-repository.git#4d79e732
│
│ # THEN: Get and cross-compile your source code. Here we use Dune and assume 'android34-ndk27-arm64-v8a'
│ ~/project$ opam install --cli=2.1 --switch android34-ndk27-arm64-v8a dune
│ ~/project$ git clone https://github.com/avsm/hello-world-action-ocaml hello
│ ~/project$ cd hello
│ ~/project/hello$ opam exec --cli=2.1 --switch android34-ndk27-arm64-v8a -- \
│ dune build -x android_arm64v8a world.exe
│
│ ~/project/hello$ file _build/default*/world.exe
│ _build/default.android_arm64v8a/world.exe: ELF 64-bit LSB pie executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /system/bin/linker64, with debug_info, not stripped
│ _build/default/world.exe: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=1731ad9ce0fdeff69df28af0b1217e843eabe26e, for GNU/Linux 3.2.0, with debug_info, not stripped
│
│ # You can also directly use the ocamlfind -toolchain
│
│ ~/project$ opam exec --cli=2.1 --switch android34-ndk27-arm64-v8a -- \
│ ocamlfind ocamlc -config-var native_c_compiler
│ gcc -O2 -fno-strict-aliasing -fwrapv -pthread -fPIC -D_FILE_OFFSET_BITS=64
│
│ ~/project$ opam exec --cli=2.1 --switch android34-ndk27-arm64-v8a -- \
│ ocamlfind -toolchain android_arm64v8a ocamlc -config-var native_c_compiler
│ /home/circleci/android-sdk/ndk/27.1.12297006/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android34-clang -O2 -fno-strict-aliasing -fwrapv -pthread -fPIC -D_FILE_OFFSET_BITS=64
└────

DkML supports three out of the four supported Android ABIs. The three
ABIs (all but `x86') were chosen based on [statistics for a large game
on Aug 29, 2023]:

━━━━━━━━━━━━━━━━━━━━━━
Arch Percent
──────────────────────
arm64-v8a 68.66
armeabi-v7a 30.38
x86_64 0.71
x86 0.26
━━━━━━━━━━━━━━━━━━━━━━

and also [Google's recommendation]:

*Note*: While 64-bit-only devices will grow in popularity with phones
joining Android Auto in this group, 32-bit-only devices will continue
to be important for Android Go, Android TV, and Android Wear. Please
continue supporting 32-bit ABIs; Google Play will continue serving
32-bit apps to 32-bit-only devices.

Finally, a word of *CAUTION*. The Android cross-compiler /can never/
use OCaml 5+ because [OCaml 5 will never bring back the 32-bit
instruction set]. That means if you don't want to drop a large percent
of your users or drop new Android categories over the next five (?)
years, you will have a critical dependency on DkML.

[dkml-compiler Quick Start]
<https://github.com/diskuv/dkml-compiler?tab=readme-ov-file#quick-start>

[statistics for a large game on Aug 29, 2023]
<https://github.com/android/ndk/issues/1772#issuecomment-1697831518>

[Google's recommendation]
<https://android-developers.googleblog.com/2022/10/64-bit-only-devices.html>

[OCaml 5 will never bring back the 32-bit instruction set]
<https://discuss.ocaml.org/t/32-bit-native-code-support-for-ocaml-5/12583/13?u=jbeckford>

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

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

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

• [Developer education at Jane Street]
• [Solving Puzzles in Production with Liora Friedberg]
• [MetAcsl v0.7 for Frama-C 29.0~ Copper]
• [Introducing the Dune Developer Preview: A New Era for OCaml
Development]
• [Unlock your Team’s Potential with Expert Training in OCaml,
Cybersecurity Fundamentals, Functional Programming, and More]
• [Alt-Ergo 2.6 is Out!]
• [Happy eyeballs?!]

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

[Developer education at Jane Street]
<https://blog.janestreet.com/developer-education-at-jane-street-index/>

[Solving Puzzles in Production with Liora Friedberg]
<https://signals-threads.simplecast.com/episodes/solving-puzzles-in-production-with-liora-friedberg-dk6vYnK2>

[MetAcsl v0.7 for Frama-C 29.0~ Copper]
<https://frama-c.com/fc-plugins/metacsl.html>

[Introducing the Dune Developer Preview: A New Era for OCaml
Development]
<https://tarides.com/blog/2024-10-03-introducing-the-dune-developer-preview-a-new-era-for-ocaml-development>

[Unlock your Team’s Potential with Expert Training in OCaml,
Cybersecurity Fundamentals, Functional Programming, and More]
<https://tarides.com/blog/2024-10-01-unlock-your-team-s-potential-with-expert-training-in-ocaml-cybersecurity-fundamentals-functional-programming-and-more>

[Alt-Ergo 2.6 is Out!]
<https://ocamlpro.com/blog/2024_09_01_alt_ergo_2_6_0_released>

[Happy eyeballs?!] <https://blog.osau.re/articles/happy_eyeballs.html>

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: 48034 bytes --]