OCaml Weekly News

Would there be a chance to connect with the work on specifying colors and color profiles in @dbuenzli's basic graphics Gg library (see Gg.Color documentation)? From the interface that you provide, it is not completely clear to me how flexible color computations can be – you provide an HSLA color space, but a linearized sRGB space would be also convenient for example, and Gg provides one.

To work with colors, note there is also Color brewery (not yet in opam) which is compatible with Gg.color. I concur with @gasche, it is good if all these libraries can work together.

https://github.com/anuragsoni/color/tree/0.2.0

I have updated the library with more utilities to work with colors. Some other changes since last time is the use of Gg.Color.t as the color type. So one can use other methods from the wonderful gg library to tweak/modify their colors, or use color palettes like the ones from color-brewry

i'm pleased to announce the first release of derive-ocaml a set of rust macros 1.1/2.0 (similar to ppx) to generate boilerplate of writing rust stubs for ocaml external calls.

The crate has no runtime and relies on the ocaml for all the ocaml runtime bindings.

The macros are still a bit experimental but should make ocaml/rust ffi much easier to crawl. Also while here i'd like to thank @zshipko for maintaining and improve the ocaml crate !!

> So this is to allow calling Rust from OCaml?

yes,but mostly it's helper to derive conversion from and to ocaml types to rust structures/enums. This is the main feature, it generates boilerplate code to call store_field()/field 'macros' like in C. On top of that it has some glue to make rust functions "nice" looking by hiding CAMLparams and co macros.

You can see a very basic example here:

• ocaml side
• rust side

https://github.com/UnixJunkie/orrandomForest

Quite hackish but working. The interface is similar to my other "R-wrapping packages". Data are exchanged via text files.

Should land soon in opam.

> but even plain text files of good documentation

We even have better than that.

We have the ocamldoc language. It allows to have your documentation exactly where it is needed, in mli files, and will carry itself if you move your sources around.

The ocamldoc language is a fully featured document markup language with sectioning and checked cross references to sections and API entry points.

Doing manuals and tutorial inside .mli always felt a bit cumbersome but is entirely doable as can be witnessed in many of my packages (see this one for example). The good news is that nowadays we will gradually be able to write those larger pieces in seperate .mld files. Code sample extraction is not there yet but I hope we can have a simple design implemented soon rather than having these discussions.

The other good news is that as a programmer, the effort you need to provide in order to make the documentation you write in this language available to end-users is this: approaching zero:

• If you are using topkg or dune-release (assuming they didn't kill that workflow), publishing your docs online on github is a topkg distrib && topkg publish doc away.
• Distributing this documentation with your package releases is also automatically done if you use topkg+ocamlbuild or dune: these systems compile and install the right files which odig can then pickup in order to generate cross-referenced documentation for all the packages that are installed in your opam switch and allows you to peacefully read all this wondefully produced documentation offline with the stylesheet that suits you.

One might complain that the ocamldoc language syntax is none of these alternative document markup languages whose popularity came after ocamldoc's initial existence but if you ever tried to write a polymorphic variant in a markdown code span you will be glad that ocamldoc's language isn't that one.

I understand the ocamldoc language is one more thing to learn as a newcomer but it's not hugely complex, it's there, it works with the advantages highlighted above and an aspiring OCaml working programmer shall meet it quite soon anyways since there are thousands of lines of documentation in hundreds of projects that are using it.

Just wanted to plug OCamlverse. Not only can anyone contribute via PR, anyone can have commit rights as well.

We already have a quickstart page for setting up Dune and such. I'd love to have more content there for getting OCaml concepts like concurrent programming up and running quickly.

We are happy to announce the opam 2.0.0 final release candidate. Hooray! :tada: It will be promoted to 2.0.0 proper within a few weeks, when the official repository format switches from 1.2.0 to 2.0.0. You'll find all information about opam update & repository upgrade in this blog post.

Big thanks to all who helped test and polish the release!

The roadmap is detailed in this blog post.

The goal of this 3rd-party repository is to provide a minimal and idiomatic template for setting up an OCaml project. It was just updated to use dune instead of jbuilder.

For those migrating, the changes are minimal and detailed migration help is given by the official docs.

I have a dead simple, feature poor tool in this direction which I've used for my own toy purposes: https://github.com/shonfeder/nomad

Its in't updated to use the dune rebranding or to be compliant with the new release.

I'm glad to hear that the views about integrating this functionality directly into dune have changed! I'd be happy to help with that effort.

LexiFi has an open position for a junior quantitative developer. The position could be a good fit for an OCaml developer with some interest in (learning about) numerical methods and/or financial stuff, even without a formal background in those topics.

More information: https://www.lexifi.com/careers/quantitative-developer/

On behalf of the dune team, I'm proud to announce the 1.1.0 release of dune. This release contains a few interesting features that I won't describe in this post, because I've already written a dedicated blog post about this release: http://rgrinberg.com/posts/dune-upcoming-1-1/

The change log is replicated here for your convenience:

Cross-posted-ish from: https://forum.sentry.io/t/a-work-in-progress-ocaml-sdk/4406

I've been wanting to use Sentry with OCaml, and ended up writing my own library for it. I thought other people might be interested to, so:

https://github.com/brendanlong/sentry-ocaml

It currently only works with Async and not Lwt or synchronous/stdlib only. If anyone else is interested, I'd definitely like to support those. And feedback would definitely be nice.

You basically just do this at the start of your program and it will load SENTRY_DSN (and some other things) from your environment and upload any errors in the background:

Sentry.with_context  @@ fun () ->

You can also set custom tags and upload exceptions or messages manually:

Sentry.with_environment "staging" @@ fun () ->
Sentry.with_tags [ "method", "POST" ; "path", "/example" ] @@ fun () ->
Sentry.capture_message "this will have the environment and tags above merged with the defaults"

Results look like:

Note that it works a lot better if you use exceptions and not Or_error.t, although if someone wants to improve the Or_error.t parsing, pull requests would be welcome for that too.

The morning paper is an amazing blog where the author posts summaries of research papers. Today's edition covers the recent (PLDI 2018) article (PDF) on the memory model proposed for the Multicore OCaml implementation:

Bounding data races in space and time – part I

Part II is now available.

I'm pleased to announce that Balancer 1.0 is now available on opam, it's a collection of load balancing algorithms, such as p2c, consistent hashing + least loaded, p2c with partial key grouping, round robin, etc.

All of the balancers are written with service discovery in mind, so you can plugin a react signal and use a watch with zookeeper or whatever.

It also comes with some useful synchronization utils for shared mutable state.

I think it's a useful addition to the ecosystem, just because people scale ocaml by spawning a lot of processes and talking via tcp, domain sockets, files, etc, and I'm actually surprised there wasn't a library for it beforehand.

https://github.com/xnukernpoll/ocaml-balancers

https://opam.ocaml.org/packages/balancer/

A pair of great posts discussing @stedolan's now-famous PLDI paper! :tada:

https://blog.acolyer.org/2018/08/09/bounding-data-races-in-space-and-time-part-i/

https://blog.acolyer.org/2018/08/10/bounding-data-races-in-space-and-time-part-ii/

https://blog.janestreet.com/what-the-interns-have-wrought-2018/

http://www.dra27.uk/blog/platform/2018/08/15/dune-vendoring.html

I've refreshed the opam2 PPA infrastructure to make binary packages available for Ubuntu, ahead of the stable release of opam 2.0.0. These can be used with (e.g.) Travis CI for non-container based builds from an Ubuntu base, without having to wait for the upstream packages to get the latest version of opam.

The packages currently sit in my experimental PPA tree at avsm/ppa-opam-experimental, so if anyone can test them and let me know if you run into any problems, I'd appreciate it.

Sources to the scripts and more information in the README:

• https://github.com/avsm/opam2-ppa

If anyone would like to help with including opam 2 in more upstream distributions as we approach release, please refer to the distributions wiki and pick your favourite OS :)

I’m happy to announce aws-s3 4.0.1

The aws-s3 library provides access to Amazon Simple Storage Solution (S3). Operations include: get, put, head, delete, delete_multi, ls, multipart upload and s3 to s3 copying. The library includes functions to get machine role and security token (credentials) through AWS Identity and Access Management service (IAM). The library supports both lwt and async concurrency models.

Lots of changes have been made in this release, but most noticeably is the introduction of a streaming api, which will reduce latency and memory footprint as objects does not need to be held in memory in full during transfer.

The release contains some trivial breaking changes (module renaming), and upgrading should be strait forward.

Changes since version 3.0.0:

• Support HEAD operation on objects.
• Change signature to use string for etag rather than Caml.Digest.t
• Support Digest 0.6
• Remove dependency to Core
• Rewrite authentication code
• Switch to use Ptime for time conversion routines
• Support chunked transfer (put)
• Add streaming API
• Remove dependency on Cohttp
• Switch to dune
• Support IPv6
• Add option to use expect-100.
• Add option to limit result of ls
• Extend aws-cli
• Move region related functions to own Region module
• Fix bug when parsing multi delete reply in case of error

The package is available through opam.

Here is a sneak peek at some potential future features of the Ocaml compiler, discussed by their implementers in these Github Pull Requests.

• Format semantic tags as extensible sum types
• Add Set.disjoint

Here are links from many OCaml blogs aggregated at OCaml Planet.

• TzDrawIt, a decentralized drawing app on Tezos
• Full Time: Software Developer (Functional Programming) at Jane Street in New York, NY; London, UK; Hong Kong
• Full Time: Compiler Engineer at Jane Street in New York & London
• Not-learning is a skill too
• opam 2.0.0 RC4-final is out!