Re: goops/guile doc (was Re: Simple example program to illustrate Goops)

[Greg Harvey <Greg dot Harvey at thezone dot net>]

Jim Blandy <jimb@red-bean.com> writes:

> [Replying to old mail...]

[Replying to an old reply to old mail...]

> I think it's a mistake to try to make GOOPS look like C++, or Visual
> Basic, or Java.  The CLOS approach is just really different, and
> anything that tries to hide that, I think, will be weird and
> confusing.
> 
> I think the only winning approach is to simply document what GOOPS
> really is, and do that well.
> 
> I think imitating the examples that appear in the Perl and Python
> documentation is a good start, but we should also try to show the
> cool features unique to GOOPS.

If you're refering to the little discussion I had with lalo, I think
you've missed the point(s). Probably the most important (i.e. point
with a definably useful purpose) is that having a somewhat simplistic
wrapper around goops providing the typical notions from java or c++
would make it much easier to write a translator for such languages (if
not, any translators are likely going to have to implement very
similar stuff over and over again). This would be a pretty big win,
since the bulk of popular languages out there tend to fall in this
category, so making a translator becomes much simpler.

My point was that being able to see, in action, how a familiar view of
the world (Java was on my mind, since I'm marking for a course that
uses java this semester) translates into goops would be a good
learning tool (not a replacement for good documentation, mind, but a
tool to go along with good documentation). In learning a new language,
you generally have to tackle three things:

1) Syntax (all those parenthesis)
2) Semantics (what those parenthesis mean)
3) Philosophy (tail recursion is cool!)

Now, what I had in mind wouldn't be something that you'd use for real
programming (you have <useful wrapper>, then <baby wrapper> :), but it
could help with each of the above points

1&2) Let's you see what something familiar in language foo becomes in
     goops; it won't necessarily be a 1<->1 translation, but not being
     a 1<->1 translation would probably be even better, because it'd
     be introducing new ideas; spitting out comments that would refer
     to certain points in the documentation would be great.

3) If nothing else, it would provide a useful introduction to
   interactive programming with scheme, rather than compile, test,
   debug, etc... this is one of the extremely useful aspects of lisp
   that doesn't get enough publicity... not just because scheme
   provides the facility (there's dynamic java, for instance), but
   because lisp seems more natural in this use than most other
   languages (likely because you can write so much in so little
   lisp). Coming over from the drudge languages, this is something you
   can't introduce soon enough for useful things (not just as a
   calculator).

For the most part though (since I don't even have time to work on the
stuff I'm supposed to have finished months ago :(, it's a bit of a
moot point.

-- 
Gregh