[racket] Processing and Racket

7 hours ago, Sean McBeth wrote:
> I had some thoughts today about Racket and apparent influences it
> has had on Processing (and by extension Arduino). I'd be interested
> to hear what the Racket community itself thinks of Processing and
> the sorts of things people do with it, in comparison to Racket.
> 
> http://moron4hire.tumblr.com/post/51904590190/processing-and-racket

Some random comments (keeping Matthias's comments in mind, so I try to
not repeat them):

* When you talk about the visual design of the web pages, there are
  actually two different things that play together here, and they are
  also coming from very different pieces of code.  (Yes, this whole
  point is pretty much a technicality, but it's rare to find people
  who pay a lot of attention to it...)

  The first is the actual *web* pages which are built in a more or
  less traditional way that spits out HTML directly.  Here there were
  some suggestions to improve the contents a few times, but nobody
  made a more serious attempt, yet.  But really, the main point is
  that anything can be done, provided it fulfills the basic
  requirements of being useful enough, clear enough, appealing enough,
  informative enough, and get most people to want to switch to it.
  (And BTW, *many* completely tiny aspects of the web page have been
  thoroughly discussed...)

  The second system is the documentation -- which is what you see in
  the example in your snapshot.  The thing here is that you want some
  way to render documentation so it can fit in both HTML and PDF and
  whatever else -- which makes the kind of rendering much more
  restricted.  There's not much that can be done at the rendering
  level without substantial effort, but probably some improvements can
  be done at the CSS level.  As a side-note, the actual contents that
  you see on the web is a weird combination of the two: taking the
  usual web page templates and slapping it on the documentation pages
  (which originally look like the locally-installed documentation that
  you see in your Racket installation).

* "Make more dynamic examples for beginners".

  IMO, this is not a good title for what you seem to be saying...
  It's not the dynamism, or the beginner-ism that is important in what
  you're saying.  If it was, then I think that we have a ton of them,
  and more are being made every day...  (See for example the
  rosettacode thing (http://rosettacode.org/wiki/Category:Racket)
  which is becoming a nice repository for lots of such examples, at
  varying levels.)

  Instead, I think that your main point is about the presentation of
  the examples -- the Processing page that you point to is very
  obviously visual.  It's actually visual enough to make me suspect
  that it's covering a shallow language since it tries so hard to make
  cute examples instead of focusing on contents.  Given that the
  visual appeal is so important for you, I think that the "Quick"
  tutorial was probably something that looks misguided: it uses
  visuals as a way to introduce the language, but the visuals
  themselves are just demonstrations of things you can do with a
  language, and not a goal in their own appeal-ability.

  But I don't think that there's any reason to choose either this
  approach or that approach.  If the Processing thing works well for
  visual people, then it's most definitely worth trying.  And it seems
  like an itch that suits you well, so you could just as well start
  doing that kind of a page and see how it works.  We can figure out
  later a way to link it into the rest of the pages to make it stand
  out: I think that there's certainly a place for more "quick try it
  out" resources that we can point to in the "getting started" page,
  and this would fit nicely with other such entry points.

* Even more specifically, I think that it's wrong to compare Racket's
  package page (both the new one and the planet one) to the Processing
  "exhibition" page: the package pages that we have are mostly about
  libraries that you can use to make stuff up, so it's not like an
  exhibition page that demonstrates full applications -- ones that can
  be used not only as temptation points, but as templates for people
  to just take the source and try to tweak things and play with an
  existing thing rather than go build something up from scratch.

  But again, this is not to avoid your implicit criticism: I just take
  it as a call for making up such an exhibition page.  BTW, I don't
  think that this must be something that is inherently tied up to
  things that are purely visual -- the same approach can be taken with
  more CS-ish contents.  For example, I think that Danny's brainfuck
  tutorial and Matthew's scratchy toy are good candidates for such a
  thing, even when neither of them is particularly graphic.

* Finally, I notice that in the HN thread that you made someone
  pointed to this thing: http://www.texample.net/tikz/examples/all/
  and I really think that something like that would be very nice to
  have.  I think that it falls somewhere between the "real
  documentation" and an "exhibition" pages -- more like a collection
  of impressive examples and a way to quickly play with them, even
  when the visual and instant feedback are probably not helping the CS
  aspect of learning a language...

-- 
          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
                    http://barzilay.org/                   Maze is Life!