Microsoft's C# (Sharp) & .NET -- A Heads Up

[Alex Martelli]

"Mark Hammond" <MarkH at ActiveState.com> wrote in message
news:SWPf5.13166$4p3.102561 at news-server.bigpond.net.au...
> "Moshe Zadka" <moshez at math.huji.ac.il> wrote in message
> news:Pine.GSO.4.10.10007270810400.2823-100000 at sundial...
> > On Thu, 27 Jul 2000, Mark Hammond wrote:
> >
> > Hmmm...this sounds positively interesting. Do you know if there is
> similar
> > support for continuations? IOW, can Scheme be supported on IL?
>
> AFAIK, continuations are currently being fudged, but MS have promised to
> add more stuff like this after release.  Unfortunately, "after release" is
> still some time off.  For all of my MS praise in the last mail, it should
> be obvious thay are still a commercial company with a tight deadline.

I suspect their numerous stockholders would be pretty unhappy if either
of these attributes were lacking:-).


> They have said a number of times "if you can work around it, do" -

Commendably pragmatic, or blamefully unprincipled, depending on
how one chooses to look at it (I'll admit to a pragmatism bias, only
moderated by a realization of how often such workarounds end up as
short-sighted kludges leading to worse problems in the future...).


> tail-recursion turned out to be an issue that was extremely difficult to
> fudge, so support was added pre-beta.  Continuations are simpler to fudge,
> so explicit support was pushed back.

Interesting!  If I had to guess, I'd have guessed the other way 'round,
which, I suppose, just shows you how much I know about IL and code
generation for advanced/dynamic language features (==not much).

Doesn't tail-recursion just basically map down to 'rebind args&locals
suitably, then jump to the entry point', rather independent of the cross
module communication issues that IL addresses?  Or are we talking
about mutual-tail-recursion or something even more refined?  Just
for my own edification and curiosity-sating (if the Scheme compiler
you mention later is open-source, I guess I should get down to studying
how it does things, but I don't yet know of any open-source IL generating
compiler -- nor of publically available detailed preliminary specs for
NWGS/IL/whatever runtimes, etc, etc [hint, hint:-)]).


> I know of at least one (fairly) complete and fast scheme implementation.
>
> > That's sad -- JPython, CPython and Python .NET should feel the *same*.
> > That's why we have a standard (the Python Language Reference Manual).
> > I truly hope JPython and Python .NET (is that the official name)
>
> No idea what the official name is!  Python .NET seems to make sense at
> this stage.

On the ActiveState site, Python .NET _is_ used as just such an official
name (in fact, it sort of seems to be just about the only well-established
aspect of the project, judging from the dearth of info at the site:-).


> > will be similar enough to CPython that Python code will work across them
> > seamlessly.
>
> I agree.  Although there is a dilemma here - sometime you _must_ make a
> choice between the language semantics versus the platform semantics.  ie,
> it would be just as much of a shame if JPython and/or Python .NET didnt
> support enough platform semantics to make it a viable language on that
> platform, thereby keeping it stuck in an "interesting, but not useful"
flux.

A dilemma I don't envy you.  Striking a balance between "faithful
compatibility
with the old" and "exploiting new platform possibilities" is, of all
excruciating
design decisions, the least enjoyable kind, in my experience:-(.


> I dont believe this needs to be a real problem.  When implementing a new
> version of Python, you will be amazed at how much _isnt_ spelt out.
> Fortunately, the implementation is clean and available, meaning the
> existing C code is usually a better reference than the docs!  Im fairly

No Extreme Programmer will be surprised in the least at this state
of things:-).  "The code IS the docs", etc.  Actually, Brooks' observations
about architectural documents in "The Mythical Man-Month" are worth
periodically re-reading (as is the rest of the book:-).  Maybe a huge test
suite proclaiming 'you're Python iff you pass this test suite' would be the
only way to keep consistence now that we're heading towards _many_
implementations in widespread use (CPython, JPython, Python .NET --
dunno what happened to Skaller's project [Viper, was it called?] -- and
no doubt other hopefuls in the wings...).

> confident I can support all documented semantics, and plenty of
> undocumented ones.

We're all here, with fingers crossed, rooting for you on this...!!!


Alex