Logging Without Side-effects (dl.dropbox.com)

The author begins with some harsh words about conventional logging: he uses the term "dysfunctional environment" to mean "system not using functional programming", and says about attempts to separate concerns so that the programmer can focus on actually getting the job done when not looking at logging "None work. But you already knew that". On the other hand, "In functional environments, we delineate the essence of a problem from its execution model." and the author's system looks for "the essence of logging".

So, it seems we're entitled to hope that his monad-based functional logging system will accomplish what "dysfunctional" ones fail to do: separate things out so that your ordinary code isn't polluted with logging nonsense.

Here's an extract from the "demo" at the end of the presentation, illustrating the system at work. This is the Scala version; there's a Haskell one too and it looks very similar modulo syntax.

    val r =
      for {
        a <- k withvaluelog ("starting with " + _)
        b <- (a + 7) withlog "adding 7"
        c <- (b * 3).nolog
        d <- c.toString.reverse.toInt withvaluelog ("switcheroo with " + _)
        e <- (c % 2 == 0) withlog "is even?"
      } yield e

    println("Result: " + r.a)
    println("LOG")
    println("===")
    r.log foreach println

Oh. So introducing logging has required that the computation be broken down into separate steps (fair enough; that's to be expected); that the syntax be "monadized" (if you were doing this without logging and didn't need a particular order of execution, those assignments would look quite different); that every bit of the calculation that doesn't need logging have a ".nolog" appended.

Note also that for a less-toy example where you want a single log for everything your program does, the whole thing needs to get this treatment. (Either that, or you need some extra mechanism to combine the logging efforts of different bits of the system.)

This is meant to be an improvement over scattering logging statements through your code? It's supposed to reduce the intrusiveness of the logging system, and make it easier to "focus on the programming task"?

If you're going to present a logging system that is in every respect worse than the ones used in imperative, side-effect-happy, statement-based programming systems, I think it is unwise to talk about "dysfunctional environments" and "the essence of logging".