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

Alan Schmitt
2022-09-20T14:01:36Z

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

Hello

Here is the latest OCaml Weekly News, for the week of September 13 to
20, 2022.

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

Sandmark Nightly Service now reports Instructions Retired along with Time
Outreachy December 2022
Unicode 15.0.0 update for Uucd, Uucp, Uunf and Uuseg
OUPS meetup september 2022 (french only)
strymonas v2: library for highest-performance stream processing
OCaml Community Code of Conduct
Use OCaml to interact with Neovim
What will be required to transpile OCaml to Lua?
OBazl Toolsuite - tools for building OCaml with Bazel
Old CWN

Sandmark Nightly Service now reports Instructions Retired along with Time
═════════════════════════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/sandmark-nightly-service-now-reports-instructions-retired-along-with-time/10475/1>

Shakthi Kannan announced
────────────────────────

Sandmark Nightly is a service for the OCaml compiler developers that
helps benchmark the development branches of the compiler on the large
set of Sandmark benchmarks on tuned machines and reports the results
in an interactive UI. Currently, Sandmark nightly reported many
metrics including running time. But running time is a notoriously
noisy metric on modern architectures due to the effects of modern OS,
arch and micro-arch optimisations. There could be swings of 50% in
either directions when the directory in which the program is run
changes.

While we run Sandmark benchmarks on tuned machines, we still see
impact of noise on the real time measurements. To this end, we
introduce a new metric into Sandmark nightly that in addition to real
time, would help interpret the results accounting for the noise. We
now report “instructions retired” for Sandmark runs. Instructions
retired report the number of instructions executed by the program
during its run and hence is shielded from the noise that affects real
time measurements. Of course, the same number of instructions may be
discharged at different rates by the processor due to
instruction-level parallelism and hence, the instructions discharged
metric should be used in conjunction with real time measurements. For
example, if a new compiler feature adds 2 instructions to the prolog
of the function, then the instructions retired metric should inform
you how many new instructions are actually executed on top of the
baseline.

The instructions retired metric is collected from `perf' command. We
also have other useful metrics from perf such as page faults,
branches, branch misses, cache misses at various levels of the
hierarchy, etc. We will add graphs to report these going forward.
Enjoy the new feature, and as ever, report issues and bugs to
[Sandmark Issues].

The web service is available at <https://sandmark.tarides.com> and you
can select the `Perfstat Output' radio button on the left panel as
shown below.

<https://global.discourse-cdn.com/standard11/uploads/ocaml/original/2X/5/5f9d3d8d87ba6821e8f41f027ce7a6b0074ec95a.png>

After selecting the variants and a baseline for comparison, you can
view the normalised `instructions per cycle' change as illustrated
below:

<https://global.discourse-cdn.com/standard11/uploads/ocaml/original/2X/1/1baf673b1246eb3505f8603a260ee4f22f32fb85.png>

You can also request for your development branches to be added to the
Sandmark Nightly Service at the [sandmark-nightly-config] repository
for the nightly runs.

[Sandmark Issues] <https://github.com/ocaml-bench/sandmark/issues>

[sandmark-nightly-config]
<https://github.com/ocaml-bench/sandmark-nightly-config>

References
╌╌╌╌╌╌╌╌╌╌

1. Run perfstat with Sandmark nightly service. [Sandmark PR #394]
2. Add webpage with perfstat output from Sandmark. [Sandmark-nightly
PR #81]
3. perfstat.ipynb. [Sandmark perfstat Jupyter notebook]

[Sandmark PR #394] <https://github.com/ocaml-bench/sandmark/pull/394>

[Sandmark-nightly PR #81]
<https://github.com/ocaml-bench/sandmark-nightly/pull/81>

[Sandmark perfstat Jupyter notebook]
<https://github.com/ocaml-bench/sandmark/blob/main/notebooks/perfstat/perfstat.ipynb>

Outreachy December 2022
═══════════════════════

Archive:
<https://discuss.ocaml.org/t/outreachy-december-2022/10336/18>

Patrick Ferris said
───────────────────

Just a reminder the deadline for mentor signup is in 9 days, the same
day as
<https://discuss.ocaml.org/t/outreachy-summer-22-closing-commemoration-session-on-23rd-sept/10450>
:camel:

Unicode 15.0.0 update for Uucd, Uucp, Uunf and Uuseg
════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ann-unicode-15-0-0-update-for-uucd-uucp-uunf-and-uuseg/10485/1>

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

Unicode 15.0.0 was released on the 13th of september. It adds 4489 new
characters to the standard.

Given the increasing contributions from the South Asian subcontinent
to OCaml we are glad this includes support for the 42 (sic) characters
of the [Nag Mundari script]. For information about the other
additions, see the [announcement page].

Accordingly the libraries mentioned at the end of this message had to
be updated. Consult the individual release notes for details. Both
Uucd and Uucp are incompatible releases sinces new script and block
enumerants had to be added.

Note that starting from Unicode 16.0.0 – that is in a year – these
libraries will be changed to use the UTF decoders of the standard
library rather than rely on Uutf. They will thus only be available for
OCaml >= 4.14.

The OCaml tips of the [minimal Unicode introduction], which you should
read if Unicode still puzzles you, have been updated to mention the
new standard library UTF decoders.

Also, the `ucharinfo' tool distributed with `uucp'[^1] can now also
lookup characters by matching substrings in their Unicode name or name
aliases.

Best,

Daniel

A big thanks for funding from the [OCaml Software Foundation] and from
my [faithful donators].

• Uucd 15.0.0 Unicode character database decoder for OCaml.
<http://erratique.ch/software/uucd>
• Uucp 15.0.0 Unicode character properties for OCaml.
<http://erratique.ch/software/uucp>
• Uunf 15.0.0 Unicode text normalization for OCaml.
<http://erratique.ch/software/uunf>
• Uuseg 15.0.0 Unicode text segmentation for OCaml.
<http://erratique.ch/software/uuseg>

[^1]: It’s a depopt you’ll need `opam install cmdliner uutf uunf uucp'
to install it.

[Nag Mundari script]
<https://unicode.org/charts/PDF/Unicode-15.0/U150-1E4D0.pdf>

[announcement page]
<https://blog.unicode.org/2022/09/announcing-unicode-standard-version-150.html>

[minimal Unicode introduction]
<https://erratique.ch/software/uucp/doc/unicode.html>

[OCaml Software Foundation] <http://ocaml-sf.org/>

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

OUPS meetup september 2022 (french only)
════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/oups-meetup-september-2022-french-only/10492/1>

zapashcanon announced
─────────────────────

(this is in french only as the talks will be in french it’s probably
not relevant for english speakers)

Le prochain OUPS aura lieu le *jeudi 29 septembre* 2022. Le
rendez-vous est fixé à *19h* au *4 place Jussieu (salle à préciser)*,
75005 Paris.

*[L’inscription est obligatoire]* pour pouvoir accéder au meetup !

Les exposés seront également retransmis en ligne sur le [galène du
OUPS].

Toutes les informations sont disponibles sur le [site du OUPS].

*Programme :*

*COBOL 101 – Émilien Lemaire*

COBOL est un langage très ancien et est assez éloigné de ceux que nous
manipulons tous les jours. Malgré cela il reste l’un des plus utilisés
dans le monde.

Durant cette présentation je vais donc vous introduire au langage,
voir comment sont écrit les programmes, comment les variables
sont-elles déclarées et comment les manipuler. Je vais aussi vous
présenter quelques features “intéressantes” du langage, dont certaines
sont inattendues.

*OCaml Multicore – Florian Angeletti*

*Opam-bin: Opam et paquets binaires – Fabrice Le Fessant*

L’utilisation d’un gestionnaire de paquets sources comme Opam n’est
pas toujours optimale en temps, car l’outil passe beaucoup de temps à
recompiler des paquets, dèjà compilés dans le passé ou par d’autres
utilisateurs. Le plugin Opam-bin répond à ce problème en permettant de
créer à la volée des paquets binaires, qui seront réutilisés à
l’avenir et peuvent être partagés avec d’autres utilisateurs. L’exposé
montre son utilisation et comment il fonctionne.

Les présentations seront suivies par des discussions libres. Les
pizzas seront offertes par la fondation OCaml ! :pizza:

[L’inscription est obligatoire]
<https://www.meetup.com/fr-FR/ocaml-paris/events/288520108/>

[galène du OUPS] <https://galene.irill.org/group/oups/>

[site du OUPS] <https://oups.frama.io/>

strymonas v2: library for highest-performance stream processing
═══════════════════════════════════════════════════════════════

Archive:
<https://sympa.inria.fr/sympa/arc/caml-list/2022-09/msg00004.html>

Oleg announced
──────────────

As has just been announced at the OCAML 2022 workshop, the new,
re-written version of strymonas library is now available at

<https://strymonas.github.io>

Strymonas is the stream processing library that achieves the highest
performance of existing OCaml streaming libraries, attaining the speed
and memory efficiency of hand-written state machines. It supports
finite and infinite streams with the familiar declarative interface,
of any combination of map, filter, take(while), drop(while), zip,
flatmap combinators and tupling. Experienced users may use the
lower-level interface of stateful streams and implement accumulating
maps, compression and windowing. The library is based on assured code
generation (at present, of OCaml and C) and guarantees in all cases
complete fusion.

Compared with the original strymonas (POPL 2017), the new version is
completely re-written and:
• Generates not only OCaml but also C (which needs no OCaml run-time
and vectorizable)
• Has Core + code-generation Backends architecture: MetaOCaml is
needed only for the OCaml backend and benchmarks; the Core and the C
generation backend are pure OCaml. More backends can be easily
added.
• The complete fusion is now achieved in all cases
• Supports both user-friendly and familiar declarative combinators,
and low-level core of stafeful streams (which can be used together)
• Core streams support streams over tuples, records and even abstract
data types
• Fusion is now performed as normalization-by-evaluation

The paper <https://strymonas.github.io/docs/ocaml-22.pdf> and the
OCAML 2022 talk (soon to be available on YouTube’s SIGPLAN
channel, among all other talks of the ICFP 2022 event) give
more details. The github repo contains the complete code of
the library, examples and all benchmarks.

OCaml Community Code of Conduct
═══════════════════════════════

Archive:
<https://discuss.ocaml.org/t/ocaml-community-code-of-conduct/10494/1>

Sudha Parimala announced
────────────────────────

Hello all! On behalf of the OCaml CoC committee, I’d like to present
the proposed Code of Conduct for the OCaml community. We hope this is
a step towards ensuring a friendly and inclusive community for
everyone.

The CoC text, based on Contributor Covenant can be found [here].

[here]
<https://gist.github.com/Sudha247/ed049de0fd91d26f43777fb11ac0453f>

The committee
╌╌╌╌╌╌╌╌╌╌╌╌╌

The current committee consists of the following people:

• Louis Roché ( @Khady, Ahrefs)
• Marcello Seri ( @mseri, University of Groningen)
• Raja Boujbel ( @rjbou, OCamlPro)
• Simon Cruanes ( @c-cube, Imandara Software)
• Sonja Heinze (@pitag, Tarides)

Scope
╌╌╌╌╌

The spaces within the scope of the committee at the moment are:

• discuss.ocaml.org
• OCaml mailing list
• OCaml IRC
• OCaml GitHub organisation

Timeline
╌╌╌╌╌╌╌╌

The committee has discussed on the CoC text. We’d be happy to hear any
feedback from the community. If all goes well, the CoC will be
enforced roughly a month from now. We’ll keep this thread updated with
any developments.

Role of OCaml Software foundation
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

While this effort is endorsed by the OCaml Software Foundation,
they’re not directly involved with the committee’s operation or
decisions by the committee on the enforcement, and this would remain
the same in future.

Onboarding more projects
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌

The committee is open to onboarding more projects under the umbrella
of this CoC.

We see two ways to go forward:

(1) Projects adopt the CoC text and the project maintainers do the
moderation work themselves.

(2) Projects adopt the CoC text and the committee would also act as
arbitrers for violation reports submitted to them.

Ideally we could do a combination of both. Smaller projects could
possibly adopt the latter and take help from the committee for
enforcement, while bigger projects with capacity to do the moderation
themselves can adopt the CoC text. The decision to accept projects
into the umbrella lies with the committee.

We’re keen to hear any thoughts or suggestions for improvement. If
you’re interested to adopt this CoC for your OCaml project, please
don’t hesitate to post here or contact me (write to me at sudharg247
[at] gmail [dot] com or DM here) or any of the committee members (DM
here).

Use OCaml to interact with Neovim
═════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/what-will-be-required-to-transpile-ocaml-to-lua/10493/10>

Deep in this thread, Dani Dickstein said
────────────────────────────────────────

For the Neovim-specific use case, you may want to take a look at
[vcaml], which lets you write OCaml programs that interact with Neovim
over msgpack RPC. Do note though that while the library as-is should
provide you with the functionality you need, it is under active
development so the API may change (improve) in significant ways
between releases.

[vcaml] <https://opam.ocaml.org/packages/vcaml/>

What will be required to transpile OCaml to Lua?
════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/what-will-be-required-to-transpile-ocaml-to-lua/10493/14>

Deep in this thread, David Jeffrey said
───────────────────────────────────────

Doesn’t necessarily help much, but a while ago I wrote a
proof-of-concept ML-style language (using OCaml, of course) that
transpiled to Lua - <https://github.com/merle-lang/luml> (I was mostly
thinking about targeting game engines… I did enough to implement
Tetris and then gave up on it).

The module that emits Lua source code was pretty simple:
<https://github.com/merle-lang/luml/blob/master/lib/compile.ml> - I
did thinking about trying to target byte code but it seemed tricky due
to different Lua versions, I think.

OBazl Toolsuite - tools for building OCaml with Bazel
═════════════════════════════════════════════════════

Archive:
<https://discuss.ocaml.org/t/obazl-toolsuite-tools-for-building-ocaml-with-bazel/10021/10>

Continuing this thread, james woodyatt asked and Gregg Reynolds replied
───────────────────────────────────────────────────────────────────────

Any chance we might see a `conf-bazel' package added to
OPAM so a package can depend on a compatible version of
Bazel being installed on the host?

I’ve put a lot of work into seamless OPAM integration, but only in one
direction: make it easy to use OPAM resources in a Bazel build
program. I have not put much thought into integrating Bazel itself
into the OPAM ecosystem. For example publishing a Bazel-enabled
package to OPAM. It looks like writing such a conf-bazel package would
be pretty easy, but I’m not sure it would do us much good at the
moment. What specific use cases do you have in mind?

There are two ways to integrate Bazel and OPAM. One is to
automatically generate BUILD.bazel files for OPAM packages. Then Bazel
would build everything, eliminating the need for the OPAM engine. This
is the strategy followed by rust (tool: cargo_raze, evidently now
supplanted by crate_universe) and go (tool: gazelle). Unfortunately a
complete solution along these lines is not feasible for OCaml, since
source files do not carry enough information to support inference to a
build program, and OPAM packages may use a variety of build languages
(Dune, Makefiles, OMake, etc.). On the other hand, Dune seems to be
the most widely used build engine by a considerable margin, and the
Dune language is easy to parse (if not so easy to interpret), so I’m
working on a conversion tool that automatically converts Dune files to
BUILD.bazel files.

The other strategy is to rely on OPAM to build dependencies and then
“import” the built artifacts into Bazel. OBazl defines an
`opam_import' rule for this purpose, and a tool that bazelizes OPAM
switches, generating an OBazl ’coswitch’. The mapping from OPAM
package name to Bazel label is straightforward: ’yojson’ to
`@yojson//lib/yojson', ’lwt.unix’ to `@lwt//lib/unix', etc.

So in practice OBazl supports a hybrid approach. Use Bazel to build
your code, but import pre-built OPAM dependencies. To do that you run
the opam conversion tool to generate a ’coswitch’ which defines a
local Bazel repo for each OPAM package, and configure your
WORKSPACE.bazel to import those repos. Write your BUILD.bazel files
using opam labels as above. If your project already uses dune, you can
run the dune conversion tool to generate your BUILD.bazel files, which
in some cases will need some tweaking, since some Dune stanzas lack
sufficient information for conversion, and in others the conversion
code needs complicated logic that I haven’t gotten around to writing,
or that does not seem worth the bother.

The OPAM “import” conversion tool is fairly stable. It converts the
META files in OPAM into BUILD.bazel files, which include dependency
information. So when you depend on an `opam_import' target you get its
entire dependency graph.

The Dune migration tool is another matter. Reverse-engineering the
Dune language is a non-trivial task, lemme tell ya. The good news is
that after what seems like eons of work the end is in sight. I’ve been
running it against a semi-random set of projects (js_of_ocaml,
ocaml-protoc, some ppx libs, etc.) and working through the quirks
inch-by-inch. Rule stanzas are a real PITA, can I just say that? In
any case, it looks like I should have an alpha release with
documentation and some case studies within a week or so. I hope. At
the very least I’ll convert my dev configuration into something usable
by others so you can follow along if you want.

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
[online].

[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>

[online] <http://lists.idyll.org/listinfo/caml-news-weekly/>

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

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