+Kim Krecht asked me what I thought about the Kernel Programming Language. Here's what I wrote in response:

You're right that it doesn't excite me, for at least two reasons.

First, Kernel is motivated by the desire to mingle the static and dynamic phases of a programming language. I know many people find this desirable, but it is nearly the opposite of my own goals wrt PL design. If anything, I would like to see an even clearer distinction between these phases so that I can 1) automatically obtain or verify interesting information (like invariants) about a program without having to run (deploy) it, and 2) express interesting information (like invariants) about a program before I have to express details about what specifically it computes. In other words, I want to be able to read and write blueprints before I start building something (separation of concerns).

Second, I am more interested in languages guided by semantic concerns than syntactic ones. The design of Kernel (and fexprs) starts with the observation that it would be nice if we could leave some function arguments un-evaluated; it addresses that issue, then tries to make the result as palatable as possible. But I'm not interested in whether arguments are evaluated or not; I'm interested in the problems that might address, for example, how to support coinductive datatypes like streams or continued fractions. If Kernel came with a description of the problems it solves and a demonstration that fexprs are the only way to solve those problems I would be more interested. As it is, on that front I am more interested things like control categories which exploit a duality between call-by-value and call-by-name via continuations.

Furthermore, I have the feeling that simply fiddling with evaluation itself, as Kernel does, is a brutal approach and probably destroys many nice properties and guarantees that could survive a more delicate treatment.

More generally, for me Kernel is in a sense a step backward. One of my favorite things about lambda-calculus is that everything is a function, so it lets me work more directly with the semantics. But Kernel introduces a distinction between functions (applicatives) and combiners, so now I am back to having to think about syntax. In practice, I have to think about evaluation order in lambda-calculus too, but since lambda-terms have a well-defined semantics independent of evaluation, I can think about that after I've written down a program. Here again Kernel forces me to confront a problem earlier than I would like, and thus collides with the principle of separation of concerns.

This is basically my attitude toward a lot of the dynamic typing stuff. Advocates are fond of claiming it provides more freedom; to me it provides less.
Shared publiclyView activity