[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

RE: Functional Paradigm popularity and Maths (Was: XML as a transition to s-expr)

Dave S. wrote:
> > I agree
> > with Shriram: pure Scheme is the machine embodiment of an elegant
> > mathematical formalism, that can be viewed as underlying all known
> > computing operations.  Niggles about parentheses pale in
> > comparison to the sheer, mindblowing importance of this fact.
> > :O))
> I agree with the former part of this paragraph. I don't agree with
> latter "mindblowing importance" part. Valuable, absolutely. A
> fundamental idea for certain problem domains, absolutely.
> Fundamentally important to all computer-science/software-engineering
> problems, no.

Well, I said "can be viewed as underlying all known computing operations",
which as far as anyone knows, is true.  I didn't say that it's the *only*
way to view those operations.  If software design teaches us anything, it's
the existence of multiple views of any given phenomenon.

> To assert such universal importance, is tantamount (by analogy) to one
> declaring a specific discipline and field of mathematics as being the
> fundamental/essential or important element of all mathematics.

Since Church wanted to use lambda calculus as a foundation for mathematics,
and others have made progress along those lines, I'd almost be willing to
defend your analogy as reality, except it would still only be one possible
view of mathematics.

As for "mindblowing importance", I think that can quite easily be defended,
although naturally, definitions of "mindblowing" will vary.  A good
reference might be Barendregt's "The Impact Of The Lambda Calculus In Logic
And Computer Science",

When lambda calculus was invented, it must have seemed pretty important.
When its concepts resulted in the first interpreted computer language on the
planet, it must have seemed pretty important.  One could even say
"mindblowing", if not too jaded.  If it all seem less dramatic in hindsight,
why is that?  Has something replaced these fundamental ideas?  If so, what?
Does it provide more expressive power, or is it just a different view?  Is
it as rigorous, as simple, as useful, as well-understood?

> Some would argue the same for design in pure-oo languages.
> In such languages you can create your own classes and define all their
> behavior. Which I would say, in turn, defines a new language. You can
> pretty readily provide simple front ends to alter the syntax and grammar
> as well, if that is desired. (* although not nearly as intrinsic and
> efficient as scheme macro facilities *)

In the case of Smalltalk at least, I think you're right.  The gap between a
functional language and Smalltalk isn't that great, though, as I'm sure you
know.  I'm not actually arguing that Scheme is a "better" language, for most
values of "better", but rather that it's a more fundamental language, that
understanding it can help understand other languages better, and that the
converse is less true.

For me, and at least a few others I've come across, learning Scheme and some
of the concepts behind it improved my skills and understanding of other
languages, in a way that the other languages I had learned up until then did
not.  I thought I understood languages pretty well after I had developed a
little metaclass-based object-oriented language (on top of someone else's
language).  I was wrong - I was mainly copying Smalltalk, and in hindsight,
Smalltalk didn't teach me as much as I thought it did, about its own
meaning.  Scheme teaches you about its own meaning, and about the meaning of
other languages - or at least, it maps closely enough to concepts that can
do that, to provide an excellent way of learning those concepts.

> >From my perspective, this little-language notion is what
> dynamic-languages like Smalltalk have termed frameworks and components.
> I.e., they are all "little languages", which are each unique to the
> classes/interfaces of objects/components involved.

I think there can be a bit more to it, once you start actually providing a
modified language to users (e.g. Paul Graham's RTML), and allowing the
user - or yourself - a high-level way to automatically control the program.
I suppose in theory, you're still just using the underlying frameworks and
components, but it sure feels like something more is going on - perhaps
mainly because it allows users to do much more than they could otherwise.

Systems I've worked on have had graphics specification languages and
financial analysis languages, for example.  Implementing these sorts of
things as in-house applications, as opposed to shrinkwrapped products,
pretty much requires that the language you use to do it gives you high
leverage, including things like runtime evaluation of new code (or an
equivalent).  There's more than one language that can work well in this
environment; in fact, I've seen Prolog used for this kind of thing, for
example.  But the Lisps are certainly top contenders in this space.