Sat Aug 25 08:52:06 EDT 2012


Reply to Antti's article.

- Ad-hoc meaning (Forth / Machine langauge / Lisp).

  The appeal here is definitely conceptual simplicity and expressive

  The big idea I think is feedback: should interpretation be strictly
  layered (ML / Haskell style, or even to some extent the Racket
  Scheme staged macros), or should it feed back onto itself: no
  distinction between data and code.

  This feedback loop seems to be essential to keeping things
  conceptually simple at the base level.

- Types.  While typed languages are in some sense less elegant due to
  their ad-hoc structure, these systems can be useful for generating a
  different kind of expressive power.

  E.g. dispatching based on function return type for Haskell style
  type classes.  This kind of "precognition" is of a different nature
  than purely local meaning available in feedback systems.

  However, heterogenous type/meta systems impose a lot of
  problems. Most importantly maybe: simplicity of the core system is
  lost (e.g. again Haskell: type system is very complex compared to
  the lambda calculuse it "protects").

  Basically, compared to the conceptual beauty of a feedback system
  (same language is base and meta), a layered type system has a
  different kind of freedom: meta level and language level do not need
  to correspond, and thus can very widely.

  ( Note that in Haskell there are essentially 3 levels: 1. Base
  lambda calculus, 2. the type system visible by the programmer, and
  3. the implementation of all the different type system extensions
  which map abstract logic stuff to more simple constructs.  To be
  fair, 3. needs to be counted; it seems to be necessary to keep
  piling extension onto extension to work around the limitations of
  the type system.  This has to be done as part of the compiler, not
  as part of a program.  It is not very modular!  And this work cannot
  be done by mortals either... )

- On the practical side, after using both approaches fairly
  intensively I'm still not sure which one is better, but it's obvious
  they are different and lead to a different way of thinking.

  One advantage of strong type systems and impossibility of "language
  feedback" is that they seem to be easier to read.  

  The ad-hoc nature of the "implicit meaning" that is often present
  only at the time the programmer writes an ad-hoc feedback structure
  is very hard to reconstruct from the code, and is often a "short
  term memory" organization in the programmer's head.  ( Of course
  here "programmer" is me in my own experience. )

  From my experience, writing very "semantically stacked" code in a
  dynamic/feedback language is a sure way of pissing off people that
  need to maintain your code after you're done with it!

  As for writing in Haskell vs. writing in Scheme.  In Haskell I get a
  good feeling of "wow, finally" being able to express the structure
  of what I want to do.  This often leads to a better understanding,
  but being required to do so can be a pain in the ass.  In Scheme
  things go a lot faster but often I loose track because of some
  hidden inconsistencies or differences between what I think it does
  and what it is actually doing.  The latter almost never happens in
  Haskell because it's meaning is more rigid.