[ruby-talk:9454] Re: 101 Misconceptions About Dynamic Languages

Note:  the following was posted to the newsgroup comp.lang.ruby
last night, but apparently got lost by the mechanism that
forwards news to the ruby-talk list, or the nntp feed for
netlab.co.jp

So when this gets re-mirrored to comp.lang.ruby, it will
be redundant there.

From [e-mail] Wed Jan 17 09:57:49 CST 2001
Article: 8270 of comp.lang.ruby
Path: news.citilink.com!newsreader.visi.com!hermes.visi.com!news-out.visi.com!gemini.citilink.com.POSTED!not-for-mail
Newsgroups: comp.lang.ruby
Subject: Re: 101 Misconceptions About Dynamic Languages
References: <[e-mail]> <01d001c07f08$82e2c720$2e03280a@puma> <3a63590c$0$81172$[e-mail]> <028701c07f56$b1bf1960$2e03280a@puma>
From: [e-mail] (Josh Stern)
Date: 17 Jan 2001 03:50:19 GMT
Lines: 124
Message-ID: <3a65167b$0$81178$[e-mail]>
NNTP-Posting-Host: 771495cc.news.citilink.com
X-Trace: 979703419 gemini.citilink.com 81178 jstern@209.98.8.9
X-Complaints-To: [e-mail]
Xref: news.citilink.com comp.lang.ruby:8270

Christian <[e-mail]> wrote:
><Josh>
>> [ C++ is not type safe because ] it is possible to
>> accidentally dereference invalid objects and write
>> to invalid memory addresses.
></Josh>

>I haven't done that in a long time. Maybe it's because I'm an 'expert'. More
>likely it is because I very rarely need pointers (I use containers), I dont
>use delete (I use smart pointers), and I dont dereference invalid objects (I
>pass arguments by value or reference). 

References and containers can do the trick as well.  For instance, take
the following scenario:

   You create some sort of sorted container that holds 
   complex objects by value.  You lookup one of those objects 
   and you want to do a number of operations involving one of 
   its subparts. For efficiency, get a reference to that
   sub-part, so you don't need to keep asking for it or
   make an extra copy.  Then, in a moment of blindness,
   some result causes you to insert a new item in
   the container.  You may very well now have an
   invalid reference.

Even an "expert" can make such mistakes from time to time
when they are not paying attention and spend a while tracking 
them down.

>[skip rant about access to a parser that can be supplied as a library, or by
>using ANTLR]

Recalling the existence of parser generator tools is a long way from
defining and implemented an interpreted lanaguage, especially one with a syntax
as complex as C++ and an as yet not fully specified semantics.  
I take this flippancy as a sure sign that you have never attempted 
any such thing.

>> Josh> Managed C++ is apparently a new choice for the interpreted domain;
>a
>> choice which looks quite similar to C++.  So it can be evaluated
>> relative to usual set of criteria:
>>
>> a) is it cross platform
>> b) is it open source
>> c) it is fast
>> d) is it flexible
>> e) is it easy to write wrappers for calling compiled code
>> d) is it easy to embed
>>
>> I don't know the answers to these questions.  Perhaps you
>> would like to fill in?


>I am no expert on .NET.
>
>a) No, but it is straight forward to make it so. All you need is a virtual
>machine that understands IL (intermediate language). A worthy cause for all
>the Penguin hax0rs.

Ok, I certainly hope you are right about how straight forward this
is.

>b) No, but see a).
>c) I haven't done any tests yet, but I've dissasembled M-C++ and looked at
>the resultant IL. The JIT compiler produces native code from this IL, and
>the IL looks a lot like a generic assembly language with class extensions
>and type information. I intend to run some real-world performance analysis.
>d) Of course it is flexible -- it is C++ with transparent access to classes,
>methods and data defined in other languages, even across process and machine
>boundaries.

Now we are talking about also the kind of flexibility an interpreter
has, particularly for moving seamlessly between textual and executable
representations.  C++ is an unknown in this area.

>e) You don't need to 'write a wrapper for calling compiled code'. You just
>call it. 

Are you really familiar with Managed C++?  I'm not, but Microsoft seems 
to have a different ideas about it than you do:

http://msdn.microsoft.com/vstudio/nextgen/technology/managedext.asp

(search for wrapper)


>> Templates are cool, but C++ doesn't natively provide much support
>> for meta-programming.  Compare C++ with Ruby or Common Lisp
>> for the  project of listing and/or serializing and later restoring all
>> current system objects.

>There is no direct connection between meta-programming (describing types
>programmatically rather than explicitly) and persistence (object
>serialisation).

a) There is an important indirect connection
b) That's just an example.

>C++ does provide native support for meta-programming -- it's called partial
>specialisation. Partial specialisation allows you to do some quite
>remarkable things. 

I know quite a bit about templates and template 'meta-programming'.  
That's why I mentioned templates in response to your original claim 
that C++ provides good support for metaprogramming.  It doesn't.

The book _Generative Programming: Methods, Tools, and Applications_
by Czarnecki and and Eisenecker has some especially amusing chapters
on the theoretical Turing completeness template meta-programs.
But from a practical point of view, these techniques are mostly
amusing tricks.  They don't address most of the real world
meta-problems that a programmer might face and they don't
transcend the need to be able to define the executable
routines of interest at compile time, before interacting
with the user and their specific input and data.  The
ordinary function object technique is a big improvement
on C, in this regard, but still quite limited compared
to the techniques offered by an interpreted language
with closures, etc.

-= Josh