The Blag

On Moonpool

2024-02-20T00:00:00+00:00

I've been working a fair amount on Moonpool</a>. I think it occupies a fairly unique place in the new, vibrant OCaml 5 ecosystem and I'd like to explain why I think that. I'll compare it to generalist schedulers like Miou</a> or Eio</a>, to process-based parallelism libraries like Parany</a>, and to domain parallelism libraries like Domainslib</a>.

Sidekick project overview

2022-11-14T00:00:00+00:00

I've been working for years on sidekick</a>, on my free time. It's getting tiresome to put so much effort into a project in the dark, so here's some basic journaling/rambles about it.

So what's Sidekick? At first, and for a while, it was an attempt at writing a SMT</a> solver, in OCaml, following the CDCL(T) paradigm, and in a functorized way. I've gone back on at least the last point, and the CDCL(T) part might be revisited soon.

Curry-Howard is overrated

2021-02-23T00:00:00+00:00

(original title: "Curry Howard is a scam". See below.)
The Curry-Howard correspondence</a> has been talked about a lot recently, not only in Haskell circles, but also among CiC-based proof assistant practitioners (Coq, Lean, etc.). In a nutshell, it makes a deep parallel between "programs" (terms of some flavor of lambda calculus, typically), and "proofs" (these programs are a proof of their type, or more precisely they are witnesses that their types are inhabited). The most basic example is id x = x</code> which, in Haskell, would be a proof of $ \forall a. a \rightarrow a $, a trivial theorem of propositional logic.
That's all good and well, but my point here is that in practice, the equivalence is not as interesting as it first looks.
Benchpress hacking: log 1 2020-06-06T00:00:00+00:00 I've decided I want to resume blogging. So without further ado, here's a short piece about one of my side projects: benchpress</a> (with a live hosting of the web ui</a>). In short, benchpress is a tool I use for running provers, by which I mean, generally, command-line tools that take a logic problem as input, and output something about the file such as "it's a valid theorem" or "it typechecks" or some sort of failure or timeout. The idea is to make it easy to run a tool you're developing (e.g. E</a>, Zipperposition</a>, Batsat</a>, Archsat</a>, etc.) on a large set of benchmarks, and analyze the results. Solving Sudokus with msat 2019-02-26T00:00:00+00:00 The glamorous world of SAT</a> and SMT solvers</a> is usually preoccupied with proving theorems, searching for software bugs, verifying hardware, and other similarly serious business. But today, we're going to solve Sudoku</a> grids. My goal is to showcase mSAT</a>, a parametrized SAT solver written in OCaml by my good friend Guillaume Bury</a> and myself. The solver's code can be found on github</a>, but I'm going to detail the most salient parts here. Format All the Data Structures 2016-03-20T00:00:00+00:00 Last October, I moved in Nancy to start working as an engineer with Jasmin Blanchette</a> on an exciting project called Nunchaku</a>. Since my domain is formal logic, I spend a lot of time manipulating, transforming, and traversing ASTs (abstract syntax trees). My primary method for debugging is pretty-printing structures; in nunchaku, I even have a --print-all</code> flag to print the AST after each transformation, since the tool is basically a bidirectional pipeline that composes transformations. I will certainly blog on the design of Nunchaku later, but today I want to present the standard Format</a> module from OCaml, that I use for pretty-printing all my data structures. Maki: on-disk memoization for (deterministic) fun and profit 2016-02-05T00:00:00+00:00 Greating, earthlings! Today I will present an exciting new OCaml library called maki. This post will be longer as usual, because it is actually two posts in one: first, I'll present the goals of Maki, sketch its design, and present the most salient parts of its API;</li> then I will demonstrate how to use it to quickly build a (very naive) OCaml build system, featuring parallel build and cached computations thanks to Maki.</li> </ul> Tooling is Awesome 2015-10-16T00:00:00+00:00 A quick note about my current OCaml setup, in my last project, Nunchaku</a>. OCaml Compiler Hacking: how to add a primitive 2015-08-06T00:00:00+00:00 I have been hacking on the OCaml compiler recently; in particular, I added some support for coloring warning/error messages</a>. At some point during the discussion over this pull request, it became clear that colored output should only be enabled if stderr</code> was an interactive terminal (in opposition to a regular file handle or whatnot). The compiler does not link with the Unix</code> library, so I finally decided to add a primitive caml_sys_is_interactive</code>. My purpose here is to explain how it works (from what I gathered) and how to do it. Simple Refinement Types for OCaml 2015-03-10T00:00:00+00:00 For more than one year, vulnerabilies in software (especially pervasive C software) have been disclosed at an alarmingly high rate. I love OCaml, which is definitely safer, but still has gaps left open. I believe formal verification, albeit a very powerful tool, is not mature enough for most programmers (too difficult to use, requires too much efforts), so I'm thinking about alternative solutions that would be more lightweight to define and use, but would still increase the confidence in source code. So here is a draft of a relatively simple extension to OCaml, that allows to specify more invariants in types without requiring a full-fledged proof system. It's purely hypothetical and I did not implement it (nor don't I plan to do it, not before the end of my PhD). The purpose is to propose a conservative extension of OCaml with a type system that can represent more complex invariants, without putting too much of a burden on the user, in a way so adding annotations to existing programs incrementally is feasible and even easy. Introduction to Automated Theorem Proving with Logtk 2014-07-24T00:00:00+00:00 My PhD work is centered around automated theorem proving</a> in first-order logic</a>. This is obviously a very cool topic (otherwise I wouldn't have focused on it), so this post is a crash course (but the program won't crash because I use OCaml</code>) on one of the most classic method to prove (some) theorems automatically. I named... resolution! The goal is to prove some (not too complicated) theorems automatically. In other words, we want a program that reads a bunch of axioms and a formula that we conjectured is a theorem following from the axioms, and then tries to produce a proof of the theorem. In practice it's almost always done by refutation: to prove that Γ ⊢ F (formula F is a theorem under axioms Γ), we try to deduce ⊥ (false) from Γ, ¬F). The applications for this kind of technology are multiple, but afaik the prominent one is software verification — aims at formally proving that a program satisfies a specification ("not crashing" is a good start). There has been a lot of research in this area for decades, but the problem is extremely hard (only semi-decidable: you will find a solution eventually if the problem is a theorem, but might run forever otherwise). Batch Operations on Collections 2014-06-11T00:00:00+00:00 Some very common (and useful) operations, including the classic map</code>, filter</code>, and flat_map</code>, traverse their whole argument and return another collection. When several such operations are composed, intermediate collections will be created and become useless immediately after. Languages like Haskell sometimes perform optimizations that merge together the operations so as to minimize the number of intermediate collections : map f . map g == map (f . g) </code></pre> Sadly, the OCaml compiler performs very few optimizations (and in this case, the optimization would not be correct anyway, because it would change the order of evaluation and therefore side-effects). Representing Lazy Values 2014-05-02T00:00:00+00:00 A quick survey of Lazy in OCaml</h1> I remember having heard that Jane Street</a> had its own implementation of Lazy</code> values, and that it was faster than the standard one. So I played a bit with several ways of managing lazy values in OCaml. Universal Serialization and Deserialization 2014-03-12T00:00:00+00:00 TL;DR: combinators and GADTs allow to describe types in abstract enough a way that they can be converted into/from various serialization formats. Edit: the code is now available in its own repository on github</a>, and on my opam repository</a> under the name CConv</code>. Optional interfaces to Yojson, Sexplib and Bencode are also provided. QuickCheck for OCaml 2013-10-05T00:00:00+00:00 I've written, and am using, an OCaml module</a> (see the documentation</a>) that is heavily inspired from Haskell's QuickCheck. Go, C++!! 2012-12-18T00:00:00+00:00 I've recently read an interesting article</a> which shows an example of concurrency implemented in 3 differenet languages, namely Go, Erlang and C++. While the Erlang and Go examples seemed clear and concise, the C++ one looks long and hard to understand. The reason behind this complexity is that C++ does not provide a simple message passing primitive such as Go channels. And this... 2012-12-10T00:00:00+00:00 ... is how you were born</h1> The inside of a curve 2012-12-05T00:00:00+00:00 Hi, I am shuba, and I'll be using this blog to dicuss various computer graphics topics I find interesting. I might also disgress on C++, which is my main programming language. For my first article, I'll try and answer a question that's not as simple as it seems: onto what did I click? How did the program know what I clicked on? We're used to be able to click on various kinds of button, rectangular or circular. But when using image editing software such as The Gimp or Inkscape, we want to select the freeform shapes we create. Tail-recursive map in OCaml 2012-12-03T00:00:00+00:00 The List.map</code> function of the OCaml standard lib is not implemented tail-recursively. The current version (as of 4.00 on my computer) is let rec map f = function [] -> [] | a::l -> let r = f a in r :: map f l </code></pre> Debugging with DOT 2012-11-30T00:00:00+00:00 Rationale</h1> I'm starting a PhD on first-order automated theorem proving, which is the reason I'm writing an experimental theorem prover</a> in OCaml. Theorem provers are full of complicated algorithms (that I plan to write on later), and my usual techniques for debugging are twofold: Writing a lot of assert</code> to make sure invariants are not broken</li> Printing debug information on stdout, if required, to get an idea of what the prover is doing. This allows me to choose the level of detail of what is printed, depending on which incorrect behavior I'm tracking.</li> </ol> The second technique, also known as printf debugging, is quite powerful (especially since OCaml does not feature a great debugger as an alternative). However, text is not great for representing structured data, and especially graphs. Here is where I bring DOT</a> into play. Frist post 2012-11-29T00:00:00+00:00 Hi there, here is the first post on this blag</a>! There will (or should, at least) be posts on technical subjects by several authors : shuba</a>;</li> Vincent Doba;</li> Simon Cruanes</a>.</li> </ul> We expect to write on C++ programming, functional programming, logic, graphics, etc. Cheers!

The Blag

On Moonpool

Sidekick project overview

Curry-Howard is overrated

Benchpress hacking: log 1

Solving Sudokus with msat

Format All the Data Structures

Maki: on-disk memoization for (deterministic) fun and profit

Tooling is Awesome

OCaml Compiler Hacking: how to add a primitive

Simple Refinement Types for OCaml

Introduction to Automated Theorem Proving with Logtk

Batch Operations on Collections

Representing Lazy Values

A quick survey of Lazy in OCaml</h1> I remember having heard that Jane Street</a> had its own implementation of Lazy</code> values, and that it was faster than the standard one. So I played a bit with several ways of managing lazy values in OCaml.</p>

Universal Serialization and Deserialization

QuickCheck for OCaml

Go, C++!!

And this...

... is how you were born</h1>

The inside of a curve

Tail-recursive map in OCaml

Debugging with DOT

Frist post

A quick survey of Lazy in OCaml</h1>
I remember having heard that Jane Street</a> had its own implementation of `Lazy</code> values, and that it was faster than the standard one. So I played a bit with several ways of managing lazy values in OCaml.</p>`