
OCaml Workshop 2020 Online Conference is live now - mseri
https://discuss.ocaml.org/t/ocaml-workshop-2020-online-conference-is-live-now/6287/9?u=mseri
======
frou_dh
The modern OCaml tooling (opam for package management, dune for building) is
impressive.

It all feels very professional and industry-grade now. Really comprehensive
and well-designed CLIs, proper man pages for all subcommands, and sweating the
details [1]

[1] My litmus test for package managers is, when listing packages installed in
an environment, is there a flag to only list packages that were explicitly
installed? Many P-Ms fail this.

~~~
smabie
I agree, opam and dune are a great combination. Probably one of the easiest
tool-chains I've used for any language.

------
transpute
Anyone cross-compiling OCaml with OpenEmbedded and Yocto? The security
properties are attractive for IoT and embedded, but it's an ongoing challenge
to build the OCaml toolchain from scratch and build apps without leakage of
pre-compiled, native, bootstrap toolchain binaries.

With the rise of Arm and RISC-V, it would be nice to see the OCaml community
contributing to an upstream OE/YP layer.

~~~
avsm
This is indeed on our development list for this winter to integrate more. Over
in MirageOS (mirage.io), we've been working hard on getting RISC-V support in
shape, so we can build unikernels for bare metal embedded devices with a
simple "dune build @riscv-solo5".

As part of that work, a few things are going on:

\- use "dune workspaces" (essentially a cross compilation context) to build
all C bindings in OCaml packages with custom CFLAGS/LDFLAGS. Ongoing work
here:
[https://github.com/mirage/mirage/pull/1153](https://github.com/mirage/mirage/pull/1153)

\- upstream in OCaml, the core developers have specced out the design for
integrating cross-compilation more naturally into the compiler.

\- OCaml 4.11.0 has just been released with a native code RISC-V backend (and
of course has had ARM for years).

Mirage doesn't really use OpenEmbedded or Yocto, but I expect it should be
straightforward to embed the workflow in there once it's stable upstream in
Mirage itself. Any pointers to something I should read about how to get
involved in Yocto?

~~~
transpute
There's a non-upstream OpenEmbedded layer for building OCaml components, but
it jumps through hoops to coordinate OCaml toolchain with upstream OE
releases, [https://github.com/OpenXT/meta-openxt-ocaml-
platform](https://github.com/OpenXT/meta-openxt-ocaml-platform)

This could be generalized to create an upstream OE layer that uses the
upcoming cross-compiling improvements from upstream Ocaml, which would then
enable MirageOS unikernels in OE meta-virtualization,
[https://layers.openembedded.org/layerindex/branch/master/lay...](https://layers.openembedded.org/layerindex/branch/master/layer/meta-
virtualization/). RISC-V support is in early stages for meta-virt, Western
Digital added some support.

Intro to meta-virt:
[https://youtube.com/watch?feature=emb_title&v=fIbWvrlWJYg](https://youtube.com/watch?feature=emb_title&v=fIbWvrlWJYg)

Intro to Yocto:
[https://elinux.org/images/a/a8/Getting_Started_with_Embedded...](https://elinux.org/images/a/a8/Getting_Started_with_Embedded_Linux-
_Using_the_Yocto_Project_to_Build_your_Own_Custom_Embedded_Linux_Distribution.pdf)

Meta-virt mailing list would be a good place for discussion,
[https://lists.yoctoproject.org/g/meta-
virtualization](https://lists.yoctoproject.org/g/meta-virtualization)

~~~
avsm
Very handy, thanks. I notice that the openxt-ocaml-platform repo uses
ocamlbuild/ocamlfind. Life should get a lot easier when we move that to use
ocaml/dune directly -- cross-compilation really needs a lot of help from the
build system, and dune is moving fast to support these workflows.

~~~
transpute
Hopefully there can be a way to use ocaml/dune directly without importing
"everything" into each per-component build tree. OE best practices employ per-
recipe sysroots for building each component, where a minimal set of
dependencies is present for the build environment. This helps with
reproducible builds and generation of manifests for supply chain integrity.

~~~
avsm
Yes that should be fine. For incremental installation, there is a `dune build
-x` which builds using a particular cross-compilation toolchain. MirageOS
builds everything in one go, but it can be broken up too (as opam itself
does).

------
ahelwer
Anyone have experience using OCaml on Windows? I do some development for a
cross-platform project where researchers wrote one of the components in OCaml.
Installing this particular component on Windows is a giant pain requiring the
user to first install Cygwin + a couple Cygwin tools. Is this typical for
OCaml projects on Windows or do you think it'd be easy/possible to streamline
this install process?

~~~
avsm
OCaml can generate binaries that do not depend on Cygwin runtimes, and that's
a common way to ship binaries. There are a number of development shops who
have been doing that for years.

For development on Windows, Cygwin is commonly used for "casual" use, and can
be tricky to get working if you're not familiar with the quirks of that
toolchain. That's going to improve quite rapidly though: I just announced that
our development focus from the OCaml Platform for opam (our package manager)
is to get Windows support working end-to-end.

There aren't any real blockers to Windows support except for building a
critical mass of developers to smooth out the thousands of details that get in
the way right now: you can find more here:
[https://github.com/ocaml/opam/wiki/opam-2.2-slides.pdf](https://github.com/ocaml/opam/wiki/opam-2.2-slides.pdf)

From a compiler developer's perspective, the number of variations of
toolchains available on modern Windows is absolutely mindboggling. I'm looking
forward to switching to Windows 10 from my OpenBSD desktop and getting
familiar with all of this. Last time I seriously used Windows (95), the
desktop eSheep app all the rage. I'm informed that it is now available for
Windows 10: [https://www.microsoft.com/en-
us/p/esheep-64bit/9mx2v0tqt6rm](https://www.microsoft.com/en-
us/p/esheep-64bit/9mx2v0tqt6rm)

------
melling
Looks like better editor support.

He demonstrates Language Server Protocol LSP in VSCode

------
ilaksh
Anyone who sees this and is interested in Ocaml but does JavaScript normally,
check out Rescript (formerly Bucklescript/ReasonML).

~~~
WiiManic
ReScript and ReasonML are separate projects, check out the ReScript FAQs for
the relationship between OCaml/Reason/Bucklescript/ReScript.

[https://forum.rescript-lang.org/t/rescript-frequently-
asked-...](https://forum.rescript-lang.org/t/rescript-frequently-asked-
questions/59)

------
orsenthil
How to join this workshop? I cannot find a direct link to any beginner
tutorial in this program.

~~~
ivg_t
The workshop is hosted by the ICFP conference so you need to register there,
which is probably too late. But all the videos are available online and you
can post questions in the OP link to Discuss, we will try to forward it to the
workshop and later post the Q&A session on our channel (so subscribe)
[https://www.youtube.com/watch?v=E8T_4zqWmq8&list=PLKO_ZowsIO...](https://www.youtube.com/watch?v=E8T_4zqWmq8&list=PLKO_ZowsIOu5fHjRj0ua7_QWE_L789K_f)

