Previous week Up Next week


Here is the latest OCaml Weekly News, for the week of May 13 to 20, 2014.

  1. LibreS3 v0.2: Amazon S3 compatible server
  2. [JOB] Compiler engineer at Jane Street
  3. Esper is hiring!
  4. Core Suite 111.13.00
  5. Meetup OCaml-Paris (OUPS), jeudi 22 mai à l'IRILL
  6. ICFP 2014 Student Research Competition: Call for Submissions
  7. Tgls 0.8.0
  8. Tsdl 0.8.0
  9. Self contained Windows executable?
  10. OCaml 2014 - Extended deadline
  11. ML Family workshop - Extended deadline
  12. Other OCaml News

LibreS3 v0.2: Amazon S3 compatible server


Török Edwin announced:
LibreS3 0.2 was just released.

Source Download:
Binary packages(RedHat/CentOS 6/Fedora 19/Debian Wheezy/Ubuntu

The package is also available on opam:
 $ opam update
 $ opam install libres3
To configure[*]:
 $ `opam config var sbin`/libres3_setup
To start the daemon:
 $ `opam config var sbin`/libres3 start
To test it:
 $ s3cmd -c `opam config var etc`/libres3/libres3.sample.s3cfg mb s3://foo

Changes in this release include:
 * Fix daemonization at startup, and exit code on shutdown
 * Portability/packaging fixes for FreeBSD/Debian/CentOS
 * Fix pre-signed URL expiration handling
 * Reduce resource usage (number of threads)
 * Other bugfixes and improvements
 * Uses latest upstream version of all packages, should build much 
   faster as it doesn't need to rebuild ocsigenserver/ocamlnet

License: GPL-2.0 with OpenSSL exception
Status: Beta
Author: "Török Edwin" <>
Mailing list:

[*]: note: it is in sbin for consistency with binary package, so
unfortunately a simple 'opam config exec libres3' doesn't work

[JOB] Compiler engineer at Jane Street


Yaron Minsky announced:
Jane Street is looking to hire an experienced compiler engineer to
work on improving the OCaml compiler.  The focus would be on
performance-related improvements to the compiler and runtime system.
The job would also include working on other aspects of the compiler
and the supporting toolchain including our internal development tools.
We're particularly interested in people with experience in areas like
optimization, GC and language runtimes, and are happy to consider
candidates who are not (yet) OCaml experts.  The position would be
full-time, and could be based in either London or New York.

If you're interested (or know someone I should reach out to), please
email me directly, at

Esper is hiring!


Martin Jambon announced:
Esper is hiring generalist software engineers. Based in Palo Alto,
California (Silicon Valley) we're one of the only US startups that
uses OCaml in the backend. In the frontend, we use JavaScript, Java
(Android), and soon Objective-C (iOS). We're currently looking for
engineers who can work in all those areas, can contribute on day one,
and be product owners in our startup. We also like to have fun -- our
team almost escaped a Japanese puzzle room, and we won the Yosemite
Half Dome lottery, so we'll also be on top of a mountain too!

You can find out more about our company here:

This SO answer will give you an idea of how we use OCaml:

Let me know if you or anyone you know might be interested. It's
alright if the people you recommend aren't actively looking. We'd also
like to get to know people who are interested in OCaml and can give us
their feedback on our startup. I've cc'd our CEO Andrew, who would be
happy to answer any additional questions.

Core Suite 111.13.00


Ben Millwood announced:
I am delighted to announce the 111.13.00 release of the Core suite.

The following packages were upgraded:

- async
- async_extra
- async_unix
- bignum
- core
- core_extended
- core_kernel
- patdiff
- sexplib
- type_conv

With this release, we are also including a new package, patience_diff.
There's no new code here, but it's been extracted from core_extended
since it only really requires core_kernel, and can now be compiled to
JavaScript, cf.

Files and documentation for this release are available on our website
and all packages are in opam:

Here is the list of changes for this version:

## async_extra

- For `Typed_tcp.create`, added a `Client_id.t` argument to the `auth`

## async_unix

- Added `Scheduler.yield_every`, which returns a function that calls
`Scheduler.yield` every n-th call.

This is useful in circumstances where you don't have strict control
over where a deferred is examined, as in a `Deferred.List.iter`.

## bignum

- Eliminated the dependence of `Bignum` on `Re2`, and reduced
dependence from `Core` to `Core_kernel`.
- Extended the rounding interface to bring it in line with int and
float rounding.
- Improved the performance of `Bignum`'s binprot.

`Bignum`'s binprot had been to just binprot the decimal string
representation. This is both slow to do and unnecessarily big in the
majority of cases. Did something better in the majority of cases and
fell back to this representation in the exceptional case.

$ ./inline_benchmarks_runner
Estimated testing time 20s (2 benchmarks x 10s). Change using -quota

| Name                                               | Time/Run | mWd/Run   | Percentage |
| binprot roundtrip compact | 7.87us   | 490.00w   |     32.88% |
| binprot roundtrip classic | 23.94us  | 1_079.00w |    100.00% |

## core_extended

- Moved `Patience_diff` out of `Core_extended` into its own library.

## core_kernel

- Added a `Sequence` module that implements polymorphic, on-demand

Also implemented conversion to `Sequence.t` from various containers.

- Improved the explicitness and expressiveness of

`binary_search` now takes an additional (polymorphic variant) argument
describing the relationship of the returned position to the element
being searched for.

val binary_search
: ?pos:int
-> ?len:int
-> t
-> compare:(elt -> elt -> int)
-> [ `Last_strictly_less_than (** {v | < elt X | v} *)
| `Last_less_than_or_equal_to (** {v | <= elt X | v} *)
| `Last_equal_to (** {v | = elt X | v} *)
| `First_equal_to (** {v | X = elt | v} *)
| `First_greater_than_or_equal_to (** {v | X >= elt | v} *)
| `First_strictly_greater_than (** {v | X > elt | v} *)
-> elt
-> int option

- Added a new function, `Binary_searchable.binary_search_segmented`,
that can search an array consisting of two segments, rather than
ordered by `compare`.

(** [binary_search_segmented ?pos ?len t ~segment_of which] takes an
function that divides [t] into two (possibly empty) segments:

| segment_of elt = `Left | segment_of elt = `Right |

[binary_search_segmented] returns the index of the element on the
boundary of the
segments as specified by [which]: [`Last_on_left] yields the index of
the last
element of the left segment, while [`First_on_right] yields the index
of the first
element of the right segment. It returns [None] if the segment is

By default, [binary_search] searches the entire [t]. One can supply
[?pos] or
[?len] to search a slice of [t].

[binary_search_segmented] does not check that [segment_of] segments
[t] as in the
diagram, and behavior is unspecified if [segment_of] doesn't segment
[t]. Behavior
is also unspecified if [segment_of] mutates [t]. *)
val binary_search_segmented
: ?pos:int
-> ?len:int
-> t
-> segment_of:(elt -> [ `Left | `Right ])
-> [ `Last_on_left | `First_on_right ]
-> int option

- Made `Queue` match `Binary_searchable.S1`.
- Made `Gc.Stat` and `Gc.Control` match `Comparable`.
- Fixed some unit tests in `Type_immediacy` that were fragile due to

## sexplib

- In `Sexplib.Std`, renamed `Macro` as `Sexp_macro`.

## type_conv

- Removed some unused-value warnings when `with` is used in

Removed warnings in cases like:

include (module_expr : sig type t with bin_io end)

Meetup OCaml-Paris (OUPS), jeudi 22 mai à l'IRILL


Thomas Braibant announced:
A short message in french to give the program of the next OCaml-Paris
meetup, on Thursday, May 22, at 19:00 at IRILL :

J'ai le plaisir de vous annoncer que la prochaine rencontre du Meetup
OCaml-Paris (OUPS) aura lieu le jeudi 22 mai à l'IRILL, selon la
formule habituelle (exposés + discussion + pot).

Au programme, à partir de 19h00 :

- Gabriel Scherer, "Some new features of 4.02"
- François Bobot, "Forgetful Memoization in Ocaml: Ephemerons"
- Benoit Vaugon, "A new implementation of OCaml formats based on GADTs"
- Jonathan Protzenko, "Building a FIP box. War stories about  OCaml, a
Raspberry Pi, ctypes, i2c, an adafruit LCF, lwt,  cohttp, and a
soldering iron".

Lexifi a accepté d'être sponsor pour le pot, et nous les en remercions.
Toutes les infos sont disponibles ici:

Inscrivez-vous nombreux !

ICFP 2014 Student Research Competition: Call for Submissions


David Van Horn announced:
                        CALL FOR SUBMISSION

                             SRC@ICFP 2014
                          Gothenburg, Sweden
                          1-3 September 2014

                          Co-located with the
    International Conference on Functional Programming (ICFP 2014)

Student Research Competition

This year ICFP will host a Student Research Competition where
undergraduate and postgraduate students can present posters. The SRC
at the ICFP 2014 consists of three rounds:

Extended abstract round:

All students are encouraged to submit an extended abstract outlining
their research (800 words).

Poster session at ICFP 2014:

Based on the abstracts, a panel of judges will select the most
promising entrants to participate in the poster session which will
take place at ICFP. Students who make it to this round will be
eligible for some travel support to attend the conference. In the
poster session, students will have the opportunity to present their
work to the judges, who will select three finalists in each category*
(graduate/undergraduate) to advance to the next round.

ICFP presentation:

The last round will consist of an oral presentation at the ICFP to
compete for the final awards in each category.


* Both the top three graduate and the top three
                undergraduate winners will receive prizes of $500,
                $300, and $200, respectively.

* All six winners will receive award medals and a
                two-year complimentary ACM student membership,
                including a subscription to ACM's Digital Library.

* The names of the winners will be posted on the SRC
web site.

* The overall first place winner of the SRC will be
invited to participate in the ACM SRC Grand Finals,
an on-line round of competitions among the winners of
other conference-hosted SRCs.

* Grand Finalists and their advisors will be invited to
                the Annual ACM Awards Banquet for an
                all-expenses-paid trip, where they will be recognized
                for their accomplishments along with other
                prestigious ACM award winners, including the winner
                of the Turing Award (also known as the Nobel Prize of

* The top three graduate Grand Finalists will receive an
                additional $500, $300, and $200. Likewise, the top
                three undergraduate Grand Finalists will receive an
                additional $500, $300, and $200. All six Grand
                Finalists will receive Grand Finalist certificates.

* The ACM, Microsoft Research, and our industrial
                partners provide financial support for students
                attending the SRC. You can find more information
                about this on the ACM website.


The SRC is open to both undergraduate (not in a PhD programme) and
graduate students (in a PhD programme). Upon submission, entrants must
be enrolled as a student at their universities, and are ACM student

Furthermore, there are some constraints on what kind of work may be

Previously published work:

Submissions should consist of original work (not yet accepted for
publication). If the work is a continuation of previously published
work, the submission should focus on the contribution over what has
already been published. We encourage students to see this as an
opportunity to get early feedback and exposure for the work they plan
to submit to the next ICFP or POPL.

Collaborative work:

Students are encouraged to submit work they have been conducting in
collaboration with others, including advisors, internship mentors, or
other students. However, submissions are individual, so they must
focus on the contributions of the student.

Submission Details

Each submission should include the student author's name,
institutional affiliation, e-mail address, and postal address;
research advisor's name; ACM student member number; category
(undergraduate or graduate); research title; and an extended abstract
addressing the following:

* Problem and Motivation: Clearly state the problem being
            addressed and explain the reasons for seeking a solution to
          this problem.

* Background and Related Work: Describe the specialized (but
          pertinent) background necessary to appreciate the
          work. Include references to the literature where appropriate,
          and briefly explain where your work departs from that done by

* Approach and Uniqueness: Describe your approach in attacking
          the problem and clearly state how your approach is novel.

* Results and Contributions: Clearly show how the results of
       your work contribute to computer science and explain
       the significance of those results.

The abstract must describe the student's individual research and must
be authored solely by the student. If the work is collaborative with
others and/or part of a larger group project, the abstract should make
clear what the student's role was and should focus on that portion of
the work. The extended abstract must not exceed 800 words and must not
be longer than 2 pages. The reference list does not count towards
these limits. To submit an abstract, please register through the
submission page and follow the instructions. Abstracts submitted after
the deadline may be considered at the committee's discretion, but only
after decisions have been made on all abstracts submitted before the
deadline. If you have any problems, don't hesitate to contact the
competition chair.

Important Dates

* Deadline for submission: 29 June
* Notification of acceptance: 14 July

Selection Committee

Jeremy Gibbons, University of Oxford

Andrew Kennedy, Microsoft Research Cambridge

Matthieu Sozeau, INRIA Paris

Sam Tobin-Hochstadt, Indiana University

Meng Wang, Chalmers University of Technology (Chair)

Stephanie Weirich, University of Pennsylvania

Transport of your poster

You can either bring your poster on your own to the conference or mail
it to the local organizers:

Attn.: Meng Wang
Chalmers University of Technology
Department of Computer Science and Engineering
SE-412 96 Göteborg, Sweden

If you choose to mail, please make sure that the poster will arrive at
the latest on 30th August 2014.

Tgls 0.8.0


Daniel Bünzli announced:
I’d like to announce the first release of Tgls:

  Tgls is a set of independent OCaml libraries providing thin bindings
  to OpenGL libraries. It has support for core OpenGL 3.{2,3} and
  4.{0,1,2,3,4} and OpenGL ES {2,3}.

  Tgls depends on ocaml-ctypes and the C OpenGL library of your
  platform. It is distributed under the BSD3 license.

Home page:   
API Documentation:

Information about OpenGL version coverage:

It should soon be available in opam.



P.S. Some background information about the library can be found in this message:

Tsdl 0.8.0


Daniel Bünzli announced:
I’d like to announce the first release of Tsdl:

  Tsdl is an OCaml library providing thin bindings to the cross-platform
  SDL C library.

  Tsdl depends on the SDL 2.0.1 C library (or later) and ocaml-ctypes. Tsdl
  is distributed under the BSD3 license.

Home page:
API documentation:

It should be available in opam shortly.

Part of this work was made undercover while I was visiting OCaml Labs last
summer, many thanks to them for their support.  



P.S. On macosx we still have some kind of unresolved spinning bug [1]
that seem to be due to an interaction with libffi. It can be
circumvented by using a compiler switch with this patch [2] (basically
remove the -no_compact_unwind option and add -w to silence the huge
pile of warnings that ensue).


Self contained Windows executable?


Deep in this thread, Jonathan Protzenko said:
Shameless plug: there's a blog post at gagallium's which recaps the 
various versions of OCaml on windows

tl;dr :
- the "ocaml" package from the cygwin distribution is a cygwin program 
which generates cygwin executables -- these depend on cygwin1.dll to run
- the installer from is a 
native windows program, which generates native windows program -- these 
do not need anything specific to execute.

The second option does also require cygwin, however, as most of the 
ecosystem (e.g. ocamlbuild) assumes a unix-like environment.

OCaml 2014 - Extended deadline


Jacques Garrigue announced:
You have 4 more days to submit a talk proposal.
We are particularly interested in hearing from developers and hackers.


                              OCAML 2014
               The  OCaml Users and Developers Workshop
                         Gothenburg, Sweden
                         September 5, 2014

                        CALL FOR PRESENTATIONS

                      Co-located with ICFP 2014
                         Sponsored by SIGPLAN
           Talk Proposal Submission Deadline: May 23, 2014 (Extended)


The OCaml Users and Developers Workshop brings together industrial users of
OCaml with academics and hackers who are working on extending the language,
type system and tools.
Previous editions have been colocated with ICFP 2012 in Copenhagen, and
ICFP 2013 in Boston, following the OCaml Meetings in Paris in 2010 and
2011. OCaml 2014 will be held on September 5, 2014, in Gothenburg,
colocated with ICFP 2014.


Discussions will focus on the practical aspects of OCaml programming and
the nitty gritty of the tool-chain and upcoming improvements and changes.
Thus, we aim to solicit talks on all aspects related to improving the use
or development of the language and of its programming environment,
including, for example:

- compiler developments, new backends, runtime and architectures

- practical type system improvements, such as (but not limited to) 
 GADTs, first-class modules, generic programming, or dependent types

- new library or application releases, and their design rationales

- tools and infrastructure services, and their enhancements

- prominent industrial uses of OCaml, or deployments in unusual


It will be an informal meeting, with an online scribe report of the
meeting, but no formal proceedings. Slides of presentations will be
available online from the workshop homepage. The presentations will
likely be recorded, and made available at a later time.

To submit a talk, please register a description of the talk (about 2 pages
long) at, providing a
clear statement of what will be brought by the talk: the problems that are
addressed, the technical solutions or methods that are proposed. If you
wish to perform a demo or require any special setup, we will do our best to
accommodate you.


Abstract Submission Deadline: Friday, May 23, 2014 23:59 UTC-11
Notification to Speakers: Monday, June 30, 2014
Workshop: Friday, September 5, 2014

ML family workshop and post-proceedings

The ML family workshop, held on the previous day, deals with general issues
of the ML-style programming and type systems, and is seen as more research
oriented. Yet there is an overlap with the OCaml workshop, which we are
keen to explore, for instance by having a common session.  The authors who
feel their submission fits both workshops are encouraged to mention it at
submission time and/or contact the Program Chairs.

As another form of cooperation, we are considering combined post-conference
proceedings of selected papers from the two workshops. The Program
Committees shall invite interested authors of selected presentations to
expand their abstract for inclusion in the proceedings. The submissions
would be reviewed according to the standards of the publication.

Program Committee

* Esther Baruk, LexiFi, France
* Jacques Garrigue, Nagoya University, Japan (chair)
* Oleg Kiselyov, Monterey, CA, USA
* Pierre Letouzey, Universite Paris 7, France
* Luc Maranget, INRIA Paris-Rocquencourt, France
* Keisuke Nakano, University of Electro-Communications, Japan
* Yoann Padioleau, Facebook, USA
* Andreas Rossberg, Google, Germany
* Julien Signoles, CEA LIST, France
* Leo White, University of Cambridge, UK

If you have any questions, please e-mail:
Jacques Garrigue <ocaml2014 AT easychair DOT org>

ML Family workshop - Extended deadline


oleg announced:
Extended submission deadline: May 23 (Friday), any time zone
Four more days to write a 2-page abstract
Submissions of demos, case studies and informed opinions are
particularly encouraged!

Higher-order, Typed, Inferred, Strict: ACM SIGPLAN ML Family Workshop
Thursday September 4, 2014, Gothenburg, Sweden
(immediately following ICFP and preceding OCaml Users and Developers Workshop)

Call For Papers

ML is a very large family of programming languages that includes Standard ML,
OCaml, F#, SML#, Manticore, MetaOCaml, JoCaml, Alice ML, Dependent ML, Flow
Caml, and many others. All ML languages, beside the great deal of syntax, share
several fundamental traits. They are all higher-order, strict, mostly pure, and
typed, with algebraic and other data types. Their type systems inherit from
Hindley-Milner. The development of these languages has inspired a significant
amount of computer science research and influenced a number of programming
languages, including Haskell, Scala and Clojure, as well as Rust, ATS and many

ML workshops have been held in affiliation with ICFP continuously since 2005.
This workshop specifically aims to recognize the entire extended ML family and
to provide the forum to present and discuss common issues, both practical
(compilation techniques, implementations of concurrency and parallelism,
programming for the Web) and theoretical (fancy types, module systems,
metaprogramming). The scope of the workshop includes all aspects of the design,
semantics, theory, application, implementation, and teaching of the members of
the ML family. We also encourage presentations from related languages (such as
Scala, Rust, Nemerle, ATS, etc.), to exchange experience of further developing
ML ideas.

The ML family workshop will be held in close coordination with the OCaml Users
and Developers Workshop.


Since 2010, the ML workshop has adopted an informal model. Presentations are
selected from submitted abstracts. There are no published proceedings, so any
contributions may be submitted for publication elsewhere. We hope that this
format encourages the presentation of exciting (if unpolished) research and
deliver a lively workshop atmosphere.

Each presentation should take 20-25 minutes, except demos, which should take
10-15 minutes. The exact time will be decided based on the number of accepted
submissions. The presentations will likely be recorded.

Post-conference proceedings

The post-proceedings of selected papers from the ML Family and the
OCaml Users and Developers workshops will be published in the 
Electronic Proceedings in Theoretical Computer Science (EPTCS). The
Program Committee shall invite interested authors of selected
presentations to expand their abstract for inclusion in the
proceedings.  The submissions are to be reviewed according to the
EPTCS standards.

Coordination with the OCaml Users and Developers Workshop

The OCaml workshop is seen as more practical and is dedicated in significant
part to the OCaml community building and the evolution of the OCaml system. In
contrast, the ML family workshop is not focused on any language in particular,
is more research oriented, and deals with general issues of the ML-style
programming and type systems. Yet there is an overlap, which we are keen to
explore in various ways. The authors who feel their submission fits both
workshops are encouraged to mention it at submission time or contact the
Program Chairs.


We acknowledge the whole breadth of the ML family and aim to include languages
that are closely related (although not by blood), such as Rust, ATS, Scala,
Typed Clojure. Those languages have implemented and investigated run-time and
type system choices that may be worth considering for OCaml, F# and other ML
languages. We also hope that the exposure to the state of the art ML might
favorably influence those related languages. Specifically, we seek research
presentations on topics including but not limited to

  * Design: concurrency, distribution and mobility, programming for the web and
    embedded systems, handling semi-structured data, facilitating interactive
    programming, higher forms of polymorphism, generic programming, objects
  * Implementation: compilation techniques, interpreters, type checkers,
    partial evaluators, runtime systems, garbage collectors, etc.
  * Type systems: fancy types, inference, effects, overloading, modules,
    contracts, specifications and assertions, dynamic typing, error reporting,
  * Applications: case studies, experience reports, pearls, etc.
  * Environments: libraries, tools, editors, debuggers, cross-language
    interoperability, functional data structures, etc.
  * Education: ML and ML-like languages in college or high-school, in general
    or computer science curriculum.

Four kinds of submissions will be accepted: Informed Positions, Research
Presentations, Experience Reports and Demos.

  * Informed Positions: A justified argument for or against a language feature.
    The argument must be substantiated, either theoretically (e.g., by a
    demonstration of (un)soundness, an inference algorithm, a complexity
    analysis), empirically or by a substantial experience. Personal experience
    is accepted as justification so long as it is extensive and illustrated
    with concrete examples.
  * Research Presentations: Research presentations should describe new ideas,
    experimental results, or significant advances in ML-related projects. We
    especially encourage presentations that describe work in progress, that
    outline a future research agenda, or that encourage lively discussion.
    These presentations should be structured in a way which can be, at least in
    part, of interest to (advanced) users.
  * Experience Reports: Users are invited to submit Experience Reports about
    their use of ML and related languages. These presentations do not need to
    contain original research but they should tell an interesting story to
    researchers or other advanced users, such as an innovative or unexpected
    use of advanced features or a description of the challenges they are facing
    or attempting to solve.
  * Demos: Live demonstrations or short tutorials should show new developments,
    interesting prototypes, or work in progress, in the form of tools,
    libraries, or applications built on or related to ML. (You will need to
    provide all the hardware and software required for your demo; the workshop
    organizers are only able to provide a projector.)

Important dates

Friday May 23 (any time zone):   Abstract submission
Monday June 30:                  Author notification
Thursday September 4, 2014:      ML Family Workshop


Submissions should be at most two pages, in PDF format, and printable on US
Letter or A4 sized paper. A submission should have a synopsis (2-3 lines) and a
body between 1 and 2 pages, in one- or two-column layout. The synopsis should
be suitable for inclusion in the workshop program.

Submissions must be uploaded to the workshop submission website before the
submission deadline (Monday May 19, 2014).
For any question concerning the scope of the workshop or the submission
process, please contact the program chair.

Program Committee

Kenichi Asai             Ochanomizu University, Japan
Matthew Fluet            Rochester Institute of Technology, USA
Jacques Garrigue         Nagoya University, Japan
Dave Herman              Mozilla, USA
Stefan Holdermans        Vector Fabrics, Netherlands
Oleg Kiselyov (Chair)    Monterey, CA, USA
Keiko Nakata             Tallinn University of Technology, Estonia
Didier Remy              INRIA Paris-Rocquencourt, France
Zhong Shao               Yale University, USA
Hongwei Xi               Boston University, USA

Other OCaml News

From the ocamlcore planet blog:
Thanks to Alp Mestan, we now include in the OCaml Weekly News the links to the
recent posts from the ocamlcore planet blog at

Full Time: Software Engineer (Technology R&D) at National ICT Australia Pty Ltd in Sydney, Australia:

Tsdl 0.8.0:

OCaml 4.02: everything else:

Tgls 0.8.0:

Current (and future?) state of OCamlbuild parallelization:

Core_bench: better micro-benchmarks through linear regression:

Depth first search:

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