Ubigraph - I wish!

I wish we had this this when I was modelling social networks for my thesis!!

hdaemonize on hackage

Having got a green light from Andre, I uploaded hdaemonize to Hackage.

I also cleaned up the library a bit. Reading up on POSIX signals I decided that it is wrong for the daemonize library to mess with them beyond blocking HUP. Also, now it has two functions, daemonize :: IO () -> IO () which does the bare minimum, and serviced :: Program -> IO () that does that and more, for example writing a PID file, handling start/stop/restart, catching and logging exceptions to syslog.

Time to try it out in production.

R Language - once more

An early warning for the unwary hacker.

Normal-order evaluation

Y <- function (f)
  (function (x) f(x(x))) (function (x) f(x(x)))

FAC <- function (f) function(n)
  (if (n == 0) 1 else n * f(n - 1))

> Y(fac)(10)
[1] 3628000

Quoting and macros

fn <- function(x) {
   x <- substitute(x);
   f <- list(NULL, x[[2]]);
   names(f) <- c(x[[3]], "");
   as.function(f, envir=parent.frame());
}

y   <- fn(f -> fn(x -> f(x(x)))(fn(x -> f(x(x)))))
fac <- fn(f -> fn(n -> if (n == 0) 1 else n * f(n - 1)))
> y(fac)(10)
[1] 3628800

Coercions

> NULL == FALSE
logical(0)

If you are wondering what happened here, FALSE, which is a logical vector of length 1, was compared for equality with NULL, which is an empty list. To proceed with the comparison, R coerced the list to a vector of length 0. Then, two logical vectors were compared elementwise for equality, to yield the resulting vector of length 0.

Equational reasoning is not a good starting point to make sense of this:

> NULL == NULL
logical(0)

> logical(0) == FALSE
logical(0)

Side effects

> f <- function () { print("MISSILES LAUNCHED"); 1 }
> g <- function (x <- f()) { x + 1 }
> g()
[1] "MISSILES LAUNCHED"
[1] 2
> g(1)
[1] 2

Argument parsing

> f <- function (x = y + 1, y = x + 1) { y <- 2; y }
> f()
[1] 2

Summary

Can a language safely combine the above features?

Does statistics really nead such a language?

References

• Lumley T. "Programmer's Niche: Macros in {R}", R News, 2001, Vol 1, No. 3, pp 11–13
• Sungwoo Park. A critique of R. Invited talk at Japanese R Users' Meeting, December 2006
• R Language Definition

ANN: VIDEO SCREENING, A taste of Haskell (tutorial), Sat, Feb 28, 13:00-15:00, UEC, Kiev

To re-post a message from the LtU-Kiev maililng list, there will be a screening of Simon P. Jones' video tutorial A Taste of Haskell together with slides. Free entrance for up to 20 people, RSVP at the LtU-Kiev mailing list. Saturday, Feb 28, 2009. 13:00-15:00. Ukrainian Education Center, Kyiv, Ukraine. More about the venue here (eng).

LtU-Kiev mailing list

Haskell users in Kiev, Ukraine, wanted to start a user group (HUG), but it turns out there are not too many practicioners yet, so the group ended up being open to all who love and use functional languages. The common denominator is Lambda the Ultimate readership! Hence the name: LtU-Kiev.

R Language

R language (or S) is something I occasionally deal with. It is known for good libraries for statistics, but its core is a rather general programming language; it is far from being as specialized as advertised. R had even been mentioned on LtU a couple of times. R has a lot of Lisp hidden behind a C-like syntax. Lexical scoping, lambdas, lists. Something I learned today is Recall and call. The latter is not unlike a (quote)..

fac <- function (n) if (n == 0) { 1 } else { Recall(n-1) * n };
fac(10)
eval(call(fac, 10))

The downside is that the implementation is very slow. Since most operations vectorized, the argument is that it does not matter. Realistically, nobody is going to do anything about it. In terms of inter-op with libraries, would it not have been much better to have it (and its wonderful libraries) run on top of a more widely accepted runtime, or even a Scheme or CL.. UPDATE: here is a nice blog on function argument handling semantics in R, which turns out to be pretty complicated. UPDATE: I finally found the draft of the R Language Definition. The section on evaluation and argument matching is particularly interesting.

SML vs OCaml - excellent reference sheet

SML vs. OCaml. Skimming through, just found out about guards in OCaml. And F# too! Very neat. TODO: translate the reference sheet to Haskell and F#, if nobody did yet.