On Tue, 2011-07-19 at 20:14 -0400, Adam Richardson wrote:
> On Tue, Jul 19, 2011 at 6:23 PM, Brian Hurt <bhur...@gmail.com> wrote:
>         What's this awk-a-mel he speaks of?  Ocaml, pronounced
>         oh-camel, I
>         know very well, but I've never heard of this awk-a-mel.  :-)
>         
>         Seriously, his pronunciation of "ocaml" highlights, I think,
>         the core
>         problem of his talk.  There has been significant development
>         in
>         languages, just not in the popular languages.  It's been over
>         there in
>         the "fringe" languages.
> 
> 
> I will confess that as I listened to the presentation (when I got the
> email with Tim's link, I just started the video while I was working on
> some drudgery), I felt like he missed some of the language features
> promoted in functional languages. 
> 
> 
> He worded functional programming contributions in terms of advancing
> the idea of limiting/protecting variable assignment (immutability),
> and to me, that's missing the points of first class functions (which,
> in light of what he says OOP languages brought to the table, actually
> provided protected function pointers through purely functional
> languages without any need for OOP) and an emphasis on function purity
> and limiting the scope of unpure functions (to me, this goes beyond
> merely protecting assignment.)
> 
> 
> These omissions, coupled with the mispronunciations of functional
> programming language names, and the value placed on the last language
> being homoiconic (without much justification) had me wondering how
> much he actually has used languages such as OCaml or Haskell.

Homoiconic representation is fundamentally important and lacking
in other languages. The programs == data idea is what makes the
macro facility work, allows dynamic program construction, compile
to core, etc. There is a story going around that McCarthy attended
a python talk where they made the claim that python IS a lisp-like
language. John pointed out that if it lacks homoiconicity it cannot
be a lisp. (I probably have the details wrong).

OCaml came from ML but the ideas came before either one. Lisp supported
functional programming long before either language. I believe the point
Robert was trying to make was that very few languages have increased our
stock of fundamental ideas. OCaml is not one of them.

Indeed languages (like Spad) built on lisp STILL support ideas I have
not seen anywhere else (e.g. dispatching on the return type as well as
the argument types).

Robert suggests that we need to develop a standard language.
Good luck with that.

I participated in the reviews of the X3J13 Common Lisp standard
(behind the scenes by passing on my comments and markups to people who
had the proposal directly). Trying to define a "standard programming
language" would be the ultimate language war. It has been tried several
times before (PL/I included everything and C++0xxxxx is trying hard to
include everything).

At best I believe we will muddle along and I will continue to be
rejected during job interviews for working in python 2.7 and not
"knowing" python 3.0. Forty years of lisp programming just makes
me too old to hire for any "real" programming job. Heck, I probably
don't know the difference between OCaml and awk-a-mel so I clearly
cannot program. :-)


> 
> 
> I don't need to know how many digits somebody can recite Pi to, but I
> would like to know how his experience with awk-a-mel lead him to
> believe that functional programming comes down to protecting variable
> assignment :)
> 
> 
> That all said, if Clojure is the seed for the last language, I'd be a
> happy man.

I believe that Robert missed the fundamental point though. It is
NOT just the space of ideas that makes lisp "the right language". 
Another key reason is "impedance matching". (An impedance mismatch 
is when you hook a soda straw to a firehose).

Programs exist to bridge the gap between the idea domain and the
machine domain. Some languages are close to the machine, like assembler,
so you have to "carry your idea" all the way to the machine. Some
languages are close to the problem (e.g. Mathematica) but the compiler
has to cross the gap to the machine. This is where the ability to
create domain-specific languages in the same syntax matters.

Lisp is the only language I know that allows you to work across the
whole spectrum in a single language. It is possible to say
   (integrate (car x))
which takes the 0 displacement off the x pointer (machine) and then
does a mathematical integration routine (problem) and does it all with
the same syntax and semantics.

I wouldn't worry that we will stop creating new languages.
We have yet to explore the space of unicode replacements for the
semi-colon (although Fortress is starting). Kanji semi-colons.
I can't wait!

Tim Daly



-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to