[racket] Getting started with R6RS

On Sat, May 14, 2011 at 4:20 PM, Neil Van Dyke <neil at neilvandyke.org> wrote:
> Shriram Krishnamurthi wrote at 05/14/2011 03:27 PM:
>>
>> I'd put this a bit differently:
>>
>> Racket will teach you all the things that Scheme would have (i.e., it
>> would have the same contribution to your growth as a programmer), but also
>> much more because of the many things it has that Scheme doesn't have.  You
>> could stop at the "end of Scheme", or you can keep going.
>>
>
> I agree that's probably a better message.
>
> In addition, I think it would behoove us to better manage the "standards"
> perception.  The following is I think that...
>
> In the period that I've been paying attention, standards seemed to get
> really important in software industry in the late '80s and early '90s, with
> changes like as the "open systems" movement.  And then there was another
> milestone, when there was initially a ha-ha-not-falling-for-that-one-again
> reaction when historically abusive MS introduced .NET and C# (which they had
> to address by creating an "independent, open source alternative").  Plus,
> there are examples of successful standards for other languages, so having a
> standard is itself considered a best practice.
>
> When industry people come from other languages to look at Racket, they've
> already placed Racket in their conceptual framework, where "standard" is
> heavily loaded.  So, when these people read in Wikipedia and memetic
> descendants of Wikipedia that R6RS is the "standard", even though I think
> R6RS should be shot in the gut and left in a ditch to die painfully, people
> naturally assume that R6RS is the obvious way to go.  "Use non-standard?!
>  Get back from me, you satan!"
>
> So they spend the weekend trying to do something in R6RS, stumbling over
> little headaches doing that in Racket, ask questions, and are suspicious
> when Racket people try to tell them to just do things in a non-R6RS way that
> sounds like sneaky "proprietary non-standard extensions lock-in
> bad-engineering" salesmanship.  In a day or two, they've lost interest or
> written off "Scheme", and they move on to the next interesting thing to look
> at.
>
> --
> http://www.neilvandyke.org/
>
> _________________________________________________
>  For list-related administrative tasks:
>  http://lists.racket-lang.org/listinfo/users
>

Neil *exactly nailed* down my experience, in every way, down to the
exact timing.

Let me expand on that viewpoint a bit for you guys, “from the inside”
so to speak, give you some of the views that’ve floated through my
mind as I’ve gone through this process (I’ll get on to my suggestions
at the end; sorry that this is such a wall-of-text. I just thought
these thoughts might be valuable input to you guys, a point of view
you can’t often introspect.):

1) First off, and most importantly, the obsession with DrScheme is
*really* off-putting for any serious developer. I know *piles* of
programming languages, I’ve written hundreds of distinct open-source
libraries, I know more toolsets than I can even remember; coming from
a background like that, seeing references to an integrated IDE
scattered through the *language documentation* itself (as if the IDE
is a part of the language), is … alienating. At this point in my
exploration of Racket (first five minutes to an hour or so), I hadn’t
yet written off the language, exactly, but I was certainly having the
seeds of doing so sowed by this. Hell, on my first visit to the front
page, I was seeing that every single code snippet in the rotating
presentation had to repeatedly inform me that I could execute that
snippet via an IDE.

Yes, as Neil wrote above, it *might* have some nice things (I can’t
speak to that effect myself, as it won’t compile on Lion yet), but
that’s irrelevant to my point: DrScheme could make me coffee and do my
laundry for me while I program, and as a newcomer to the language, I
would *still* be put off by this level of conceptual integration,
right down to the granular documentation. Whether you like it or not,
whether they apply to DrScheme or not, there are cultural connotations
to IDEs, and a lot of veteran programmers want nothing whatsoever to
do with such a tool. If DrScheme is really such a great thing, then
you should be pipelining developers to it *through* Racket: show them
that Racket, alone, is amazing, and *then* show them that DrScheme can
make development in Racket *even better*.

2) The whole “languages” thing is nearly as off-putting as the
DrScheme obsession, but in a different way. When I come across an
instruction saying to add `#lang racket` or `#!r6rs` at the top of the
file, with no explanation of what that does, it feels more than a
little bit too much like “magic.” It feels like the language trying to
pussyfoot around inexperienced developers, hide from me operation that
is considered ‘too complex’ for me to understand.

As a “veteran programmer” (again, not trying to make myself sound
amazing; I’m absolutely sure that every person who’s replied to this
thread so far is a better programmer than me. I’m just trying to
present myself as a representative of a particular group; the group of
those like yourselves and myself, but excluding those who *already*
know Scheme … that is, the group of those like yourselves who, like
me, are *currently interested* in learning Scheme.), I didn’t
appreciate the feeling that the language was hiding something
important from me (something important enough that it involved
*competely different* syntaxes after that directive, which obviously
means the operation of that directive is “kind’uh a big deal.”)

Thus, my next step was to attempt to figure out exactly what was being
‘hidden’ from me, what those directives *actually did*. Luckily, that
didn’t take too long once I knew what I was looking for; but while
abstractions like that are great for getting straight to teaching
beginners about programming without messing about with complex
discussions of environment and conceptual set-up just to understand a
small, simple program (à la HtDP), they’re really not at all so great
for somebody like me, who expects to understand every line of the
first source-code file he’s writing in a language that is new to him,
as he writes them.

3) After the issues described above, I realized that the
‘documentation path’ I’d been following just wasn’t *for* me. Looking
around with a little bit more descerning eye, I realized that all the
documentation I could find seemed to be for children. (Don’t
misunderstand me; I’m not using that as an insult. I mean, quite
literally, the documentation seemed to be of very similar form to the
“teen-specific” books and tutorials that I had seen people passing
around for other languages like Ruby and JavaScript.)

Instead of getting right into the meat of the language, the things I
cared about learning, the first few links / examples / tutorials were
all about ‘frivolous’ things, such as creating GUIs or images; nothing
that was likely to really teach me anything about the language itself.
Those are the kinds of things you show to beginner programmers, to get
them motivated to keep learning (Hey! Look! I wrote a *program!* It
has a *button!*); and that’s fine, everybody needs motivation.
Unfortunately, a button doesn’t give someone like *me* any motivation;
we need information on the language semantics. We need to know Why
This Language is Better™ Than All The Others, and we’re not going to
get that from ‘yet another GUI toolkit.’ (Again, just as with #1, I
was accosted with this mindset with my very first visit to the
homepage, before I even knew what Racket was: the first code example I
saw was something to do with creating images or a window or something;
I immediately flipped through them, looking for something more
relevant that would give me a better taste of the language)

4) Finally, this has already been discussed a bit above, but I thought
I’d make sure I included it in this list: after my troubles with
finding any sane tutorial-style introduction to the “meat” of the
language, I decided the next best step would be to go straight to the
specification. Of course, in looking for a Racket specification, I
found the R6RS specification, and what followed was the exact chain of
thought described by Neil: “so, this is the real specification, and
Racket is just a divergent implementation, that has some weird system
that allows me to trigger it to be conformant. Geeze, anybody remember
Internet Explorer? Really.” As with the above three points, this just
led to yet more annoyance with Racket itself; and now I had an outlet:
the mythical “true Scheme.” All I wanted after this was to find a way
to run R6RS code. I subsequently forgot about Racket, except the
things I needed to know to drop into “R6RS mode,” and began to dive
into the R6RS specification (the first time, mind you, in this entire
debacle, that I felt like I was actually learning a new language,
instead of jumping through hoops.)

Unrelated note: while, according to Neil and the rest of you, R6RS may
be a bit of a joke in the Scheme community (I can’t really comment
yet, honestly) … it has a *wonderfully* well-written specification.
It’s the best technical specification I’ve ever read. It’s both exact
*and* a great introduction to the language for someone completely
unfamiliar with it. Even if R6RS itself is worthless, I certainly
suggest y’all learn as much as you can from the form and style of that
specification, and bring it back to Racket’s documentation.


… which brings me to my recommendations, after all this, and after
Neil’s (and other’s) input here: Improve your documentation-path for
non-beginners.

Of course, it’s a lot more complex than just doing that; but I hope
everything I’ve shown above will give you some input as to how to do
so.

For instance, I’m biased, of course, but I really think all of this
beginner introduction content, the HtDP-derived things, should be
moved elsewhere. They’re out of place right in the language’s official
documentation, and I don’t believe their presence there is in fact
*helping* anybody. The documentation is too hard to find and too,
well, “programmer-y” (look at the page; it’s terribly designed, it
looks like any other technical documentation out there.) Create a
seperate site, something like [the][1] [obvious][2] [examples][3] from
the Ruby world; hire or otherwise rope a *good designer* into making
it “flow” for the newcomer, and make *that* the central hub for
newcomers to programming in general and teens. That’ll help expose
them to DrRacket and Racket, and programming things like this in
general; it’s a great start.

Then, provide a clear documentation path, right from
http://racket-lang.org/ and ending in an actual technical
specification, that caters to programmers who simply want to learn
“Racket Scheme”, the language, none of the other cruft. Make sure that
path has them buried in lingual semantics and syntax as quickly as
possible, make sure it gets them writing code into a text editor and
running it on their command line (of which I guarantee you they
already at least four open) As soon As Possible.

While you’re at it (and I know this is going to raise some hackles,
but I haven’t pulled any *other* punches in this post, so why start
now?), remove every single reference to DrScheme along that path
(except perhaps exactly one, of the form “Racket provides an
integrated editor and debugger platform for you, if you wish to use
it!” … but perhaps not even that, as there’s no way of writing
“integrated editor and debugger platform” or any other mutation of
that phrase that doesn’t jump out of the page and scream “IDE! IDE!
Run away!” to most of us by now.) And (yes, more hackles), that path
includes the landing page. Select a point in the path, far enough into
the documentation that the average visitor is already going to know
some basic semantics of Racket, know a bit of the answer to that
eternal question I posed above (“Why This Language is Better™ Than All
The Others”); then relegate all mention and coverage of DrScheme to
*after* that chosen point.

Finally, relatively minor to the other suggestions … somewhere, as
soon as it’s fesible in aforementioned documentation-path, mention the
R6RS specification, and explain *why* it’s not followed. Put some
rationale in there. While you’re at it, make it easier for people to
play with ‘pure’ R6RS, even after having told them that that’s a bad
idea, so they can decide such for themselves.

  [1]: http://mislav.uniqpath.com/poignant-guide/
  [2]: http://camping.rubyforge.org/
  [3]: http://hackety-hack.com/

Postscript: I know I’m not making any friends with this post. I’m not
trying to. A lot of these opinions, and a lot of the suggestions, are
going to seem offensive from your point of view. That is, in a way, my
point: your collective points of view, as people already knowing
Racket/Scheme, are just as invalid in this discussion of a
non-Schemer’s experience with the Racket website and documentation, as
would be my own input in a discussion of a general non-programmers. I
truely hope, reading this post, you can come to understand my mindset
even if you disagree with the actual arguments made; and that you,
taking that new understanding, can create better documentation, a
better initial experience, for Racket. (-: