Re: [racket-users] hackernews

[Jesse Alama]

On 27 Dec 2018, at 0:04, Neil Van Dyke wrote:


Jason Stewart wrote on 12/26/18 5:25 PM:
Even for blue-sky projects without any legacy lock-in, I don't fancy 
our chances with the enterprise/MIS crowd.  They tend to favor 
straight-jacket languages, and for good reason!


Agreed.  (A big-corporate exception being R and "startup-like" 
units, not necessarily under MIS, like some might have in, e.g., 
fintech.)


For some guy running a two-man startup, something like Racket is a 
super weapon.  For a large organization--with any staff turnaround 
at all--metaprogramming is cancer.  They need a "paper trail" for 
the next guy to follow.


Them's fightin' words. :)  For a counterexample, consider a 
programmer inheriting a project with an LALR or LR(1) parser written 
voluminously by hand, and a programmer inheriting a project instead 
using a parser generator DSL.  The non-DSL-using code might never be 
understood enough to find the bugs or extend it correctly.  The new 
programmer might not even recognize the model that the non-DSL-using 
one is supposed to be implementing, nor stick to a documented model in 
what changes they do.  And then a third programmer comes along, and 
then a fourth...


In an organization with good software engineering, judicious use of 
DSLs, and having them well-documented, tested, and maintainable, seems 
a win.


I think bigger barriers to enterprise adoption of Racket than "I heard 
that 'metaprogramming' eats your babies" are:

(1) Wanting employees to be interchangeable cheap commodities.
(2) Wanting someone to blame/sue/consult if anything goes wrong.

I'm happy to let "the enterprise" wait to adopt Racket until after 
everyone else has had years of success stories.


I think we agree that startups are a much more likely path for Racket 
commercial uptake.


I've had some moderate success in established, non-Racket companies by 
working around -- rather than taking on and trying to replace -- the 
main language & toolchain. For the PHP shop where I work, I made a DSL 
called Riposte [1] for testing HTTP APIs. It has become, in time, the de 
facto tool for such things. Thanks to Riposte, all developers have 
Racket installed on their workstations, even though I'm the only one who 
knows Racket and can fix problems with the tool.


I made a tool (1) whose benefits to my boss and teammates are obvious, 
(2) which is clearly  hard to do in the main language, but (3) which 
would not kill the main line of development if I were to go away. A boss 
who respects his employee's skills and their need to "do his own thing" 
while still helping the company may indeed welcome Racket, in limited 
ways, on these grounds.


I might advocate for just making great tools/languages privately, then 
trying to make the argument for them later. The opposite is trying to 
get permission up-front to do something in Racket. That's less likely to 
succeed, I think, than just making something great and explaining its 
benefits, over time, at opportune moments. In my case, that meant 
talking with co-workers about their work and asking: "How can we model 
the proposed change in the API and be sure that we've really succeeded?" 
The implied answer being: "Write a Riposte script." That's the moment 
where it becomes clear that what I made has real benefits. I don't even 
"push" Racket. I just introduce the DSL and show them how it helps them.


Jesse

[1]: https://riposte.in

--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Neil Van Dyke]

Stephen De Gabrielle wrote on 12/27/18 4:47 PM:

I always wanted to ask if the prototype object model is a good idea or bad idea?


I think it's not a bad idea, but I think you probably wouldn't use it 
for general-purpose OOA, OOD, or OOP right now.  For a long time, OO 
overwhelmingly embraced mostly the same class-instance-inheritance 
model.  Recently, we're seeing some newly popular languages back off 
from that very familiar model, including dusting off some ideas like 
traits/interfaces and mixins/composition.


I currently suspect that prototype models might be most useful for 
*not-very-programmer-ish end user* HCI models, when you don't want to 
deal in conventional types, or you can't.  My most recent example, the 
last few weeks, is finding a usable end-user semi-natural language DSL 
for nutrition tracking.  Consider that you want to very rapidly capture 
information about what you cook and eat.  You have concepts of 
ingredients and quantities.  You might also have concepts like how you 
usually make your coffee, or a few sandwiches and soups you often make 
the same.  You also have dishes that you make less-often or are 
one-offs.  You have leftovers, and the leftovers can evolve.  And you 
always want your nutritional intake tracked.  It's looking like the 
conceptual model backing a quick semi-natural language for this might 
indeed be a prototype object model, in which there's a lot of 
like-that-but-different-and-distinct.


Maybe (just speculating, off the cuff) it turns out there's also a place 
for prototype object models in symbolic machine learning, in acquiring 
some variation on frame-based representations of knowledge.


Obligatory Racket: You can make your own prototype object model in 
Racket pretty easily, a number of ways.  You can do some ways in an 
hour, or spend a day on linguistic tweaking, or spend a week or more 
making it faster or working through some ideas you thought of while you 
were working through it.



The same question applies to Morphic User Interface Construction Environment - 
good idea or bad idea?


I haven't had a chance to play with the latest work in this space, and 
maybe someone else here can talk about how the latest work conceptualizes.


It might be a coherent basket of things that you already see many 
places, and will increasingly see even more (direct manipulation user 
interfaces, composing/decomposing systems as interacting concurrent 
objects and aggregations/assemblies, maybe adapt to augmented reality 
interfaces for ubiquitous programmable things/materials in real space, 
etc.).


Also, who knows what happens, if large numbers of kids can build with 
this and other complex models during early developmental years?  Maybe 
we start seeing new HCI that takes advantage of a facility with those 
models.  Or we see new perspectives/understandings, due to the popularly 
expanded mental machinery.  (They'll need the new powers, to deal with 
everything the last 20 years of CS did through dotcoms.)


--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[racket-users] Extracting known keywords from make-keyword-procedure

[Sorawee Porncharoenwase]

In Python, we can extract known keywords easily:

def f(a, *args, b=2, c=3, **kwargs):
 return (a, args, b, c, kwargs)

print(f(42, 43, c=44, d=45)) #=> (42, (43,), 2, 44, {'d': 45})

Doing so in Racket is not as easy. 

#lang racket/base

(provide lambda/kw define/kw)
(require racket/list
 (for-syntax racket/base))

(define-syntax-rule (lambda/kw (kws kw-args . rst) body ...)
  (let ([f (λ (kws kw-args . rst) body ...)])
(define-values (ignored used-kws) (procedure-keywords f))
(make-keyword-procedure
 (λ (actual/kws actual/kw-args . actual/rest)
   (define-values (used-kws+kw-args left-kws+kw-args)
 (partition (λ (e) (member (car e) used-kws))
(map cons actual/kws actual/kw-args)))
   (keyword-apply f
  (map car used-kws+kw-args)
  (map cdr used-kws+kw-args)
  (list* (map car left-kws+kw-args)
 (map cdr left-kws+kw-args)
 actual/rest))

(define-syntax-rule (define/kw (f . rst) body ...)
  (define f (lambda/kw rst body ...)))

(module+ test
  (require rackunit)
  (define/kw (f kws kw-args #:b b #:c [c 16] #:d [d 32] a . rst)
(list kws kw-args a b c d rst))

  (check-equal? (f 1 2 #:b 4 #:c 8 #:e 64) '((#:e) (64) 1 4 8 32 (2

While I am happy with the above macro, I wonder if this could be a part of 
`make-keyword-procedure`, so that we can simply use:

  (define g (make-keyword-procedure
 (λ (kws kw-args #:b b #:c [c 16] #:d [d 32] a . rst)
   (list kws kw-args a b c d rst

  (check-equal? (g 1 2 #:b 4 #:c 8 #:e 64) '((#:e) (64) 1 4 8 32 (2)))



-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Hendrik Boom]

On Thu, Dec 27, 2018 at 02:06:22PM -0800, Andrew Gwozdziewycz wrote:
> On Thu, Dec 27, 2018 at 8:24 AM Brett Gilio  wrote:
> >
> >
> > Hendrik Boom writes:
> >
> > > On Wed, Dec 26, 2018 at 09:51:17AM -0500, Neil Van Dyke wrote:
> > >>
> > >> Python started out as some guy on Usenet with a reusable extension
> > >> language (Tcl was another, and some RnRS implementations were another)
> > >> -- all 3 of them had interesting innovations and merits. (Tcl got
> > >> popular because of Tk GUIs, and then it has some moments in the sun
> > >> for earlier database-backed Web servers (as opposed to manually-edited
> > >> HTML) while a lot more readable than Perl, and was pushed commercially
> > >> by Philip Greenspun, before Sun hired Tcl creator Ousterhout, and Tcl
> > >> disappeared, in favor of Java and then LiveScript/JS.)
> > >
> > > I seem to remember hearing that Scheme was one of the
> > > inspirations for Python.  That and another language.
> > >
> > > -- hendrik
> >
> > That other language is Dylan, which is also inspired by Scheme.
> 
> Sometime in the 2000s, I heard Guido talk at Google NYC about the
> history of Python. In the 80s he was working for / with librarians who
> used a language called "ABC."

Is that the ABC pioneered by Lambert Meertens?  I was familiar 
with it in its early days.  It was meant to be a better language 
for beginners than BASIC.

> Python was meant to be a better version
> of that. The History of Python wiki page suggests it was meant as a
> "better verson of ABC with exceptions and better integration with the
> Amoeba Operating System."[1] The exceptions originally were inspired
> by Modula-3, apparently.

Yeah.  That was the other language I couldn't think of.  One 
of my favorites for a long time, and implementations still 
available online.  An elegant language, except for its Pascal 
syntax.  

-- hendrik

> Any influence of Lisp, and Scheme came later,
> is my guess. That same page cites a quote from Guido suggesting "some
> Lisp hacker" implemented map, filter, and lambda for version 1.
> 
> 
> [1]: https://en.wikipedia.org/wiki/History_of_Python
> 
> 
> -- 
> http://www.apgwoz.com

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Andrew Gwozdziewycz]

On Thu, Dec 27, 2018 at 8:24 AM Brett Gilio  wrote:
>
>
> Hendrik Boom writes:
>
> > On Wed, Dec 26, 2018 at 09:51:17AM -0500, Neil Van Dyke wrote:
> >>
> >> Python started out as some guy on Usenet with a reusable extension
> >> language (Tcl was another, and some RnRS implementations were another)
> >> -- all 3 of them had interesting innovations and merits. (Tcl got
> >> popular because of Tk GUIs, and then it has some moments in the sun
> >> for earlier database-backed Web servers (as opposed to manually-edited
> >> HTML) while a lot more readable than Perl, and was pushed commercially
> >> by Philip Greenspun, before Sun hired Tcl creator Ousterhout, and Tcl
> >> disappeared, in favor of Java and then LiveScript/JS.)
> >
> > I seem to remember hearing that Scheme was one of the
> > inspirations for Python.  That and another language.
> >
> > -- hendrik
>
> That other language is Dylan, which is also inspired by Scheme.

Sometime in the 2000s, I heard Guido talk at Google NYC about the
history of Python. In the 80s he was working for / with librarians who
used a language called "ABC." Python was meant to be a better version
of that. The History of Python wiki page suggests it was meant as a
"better verson of ABC with exceptions and better integration with the
Amoeba Operating System."[1] The exceptions originally were inspired
by Modula-3, apparently. Any influence of Lisp, and Scheme came later,
is my guess. That same page cites a quote from Guido suggesting "some
Lisp hacker" implemented map, filter, and lambda for version 1.


[1]: https://en.wikipedia.org/wiki/History_of_Python


-- 
http://www.apgwoz.com

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Stephen De Gabrielle]

I always wanted to ask if the prototype object model is a good idea or bad idea?

The same question applies to Morphic User Interface Construction Environment - 
good idea or bad idea?

Given neither idea seems to have caught on I’m assuming both are dead ends?

Kind regards,

Stephen


> On 27 Dec 2018, at 18:46, Neil Van Dyke  wrote:
> 
> Matthew Butterick wrote on 12/27/18 12:00 PM:
>> According to Brendan Eich, "The good parts of [JavaScript] go back to Scheme 
>> and Self" [1] combined with "a lot of stupid". [2]
> 
> I appreciate Eich's candor and thoughtfulness there.
> 
> From Self, I think JavaScript initially got the prototype object model, and 
> possibly whatever slot access/dispatch optimizations Self used.
> 
> Self did some even more novel/noteworthy things, which PL enthusiasts would 
> want to know about: JIT or runtime incremental optimization, visual/concrete 
> programming active morphs worlds, and (I include this) the morphs world 
> object editors.
> 
> Self was very neat and exotic at the time I used it.  And the set of 
> innovations suggests such a pleasing causal chain of necessity being the 
> mother of invention, that I don't want to know if it's not the truth:  morphs 
> world => loose prototype-delegation concurrent objects => runtime 
> optimization.
> 
> Regarding Scheme, I suppose Eich might've just used a simple Scheme with a 
> prototype object model (it's very simple to implement).  But Java was already 
> out there, the original purpose of LS/JS (IIRC) was merely glue to load Java 
> applets (not full-GUI-application DOM manipulation and logic like today), and 
> Sun had made Java have a C++/C syntax, because that's the kind of programmer 
> they thought would be developing in it.  I suppose, as soon as I was whipping 
> up a "Java-ish light scripting language" back then, even if Scheme was my 
> inspiration, as soon as I was figuring out the different syntax anyway, I 
> probably would've simplified semantics (e.g., free tail calls and first-class 
> continuations would seem unnecessary).
> 
> -- 
> You received this message because you are subscribed to the Google Groups 
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an 
> email to racket-users+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Neil Van Dyke]

Matthew Butterick wrote on 12/27/18 12:00 PM:
According to Brendan Eich, "The good parts of [JavaScript] go back to 
Scheme and Self" [1] combined with "a lot of stupid". [2]


I appreciate Eich's candor and thoughtfulness there.

From Self, I think JavaScript initially got the prototype object model, 
and possibly whatever slot access/dispatch optimizations Self used.


Self did some even more novel/noteworthy things, which PL enthusiasts 
would want to know about: JIT or runtime incremental optimization, 
visual/concrete programming active morphs worlds, and (I include this) 
the morphs world object editors.


Self was very neat and exotic at the time I used it.  And the set of 
innovations suggests such a pleasing causal chain of necessity being the 
mother of invention, that I don't want to know if it's not the truth:  
morphs world => loose prototype-delegation concurrent objects => runtime 
optimization.


Regarding Scheme, I suppose Eich might've just used a simple Scheme with 
a prototype object model (it's very simple to implement).  But Java was 
already out there, the original purpose of LS/JS (IIRC) was merely glue 
to load Java applets (not full-GUI-application DOM manipulation and 
logic like today), and Sun had made Java have a C++/C syntax, because 
that's the kind of programmer they thought would be developing in it.  I 
suppose, as soon as I was whipping up a "Java-ish light scripting 
language" back then, even if Scheme was my inspiration, as soon as I was 
figuring out the different syntax anyway, I probably would've simplified 
semantics (e.g., free tail calls and first-class continuations would 
seem unnecessary).


--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Matthew Butterick]

According to Brendan Eich, "The good parts of [JavaScript] go back to Scheme 
and Self" [1] combined with "a lot of stupid". [2]

[1] 
https://www.jwz.org/blog/2010/10/every-day-i-learn-something-new-and-stupid/#comment-1089
 


[2] 
http://www.jwz.org/blog/2010/10/every-day-i-learn-something-new-and-stupid/#comment-1020


> On Dec 27, 2018, at 8:24 AM, Brett Gilio  wrote:
> 
> 
> Hendrik Boom writes:
> 
>> On Wed, Dec 26, 2018 at 09:51:17AM -0500, Neil Van Dyke wrote:
>>> 
>> 
>> I seem to remember hearing that Scheme was one of the 
>> inspirations for Python.  That and another language.
>> 
>> -- hendrik
> 
> That other language is Dylan, which is also inspired by Scheme.



-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Brett Gilio]

Hendrik Boom writes:

> On Wed, Dec 26, 2018 at 09:51:17AM -0500, Neil Van Dyke wrote:
>> 
>> Python started out as some guy on Usenet with a reusable extension
>> language (Tcl was another, and some RnRS implementations were another)
>> -- all 3 of them had interesting innovations and merits. (Tcl got
>> popular because of Tk GUIs, and then it has some moments in the sun
>> for earlier database-backed Web servers (as opposed to manually-edited
>> HTML) while a lot more readable than Perl, and was pushed commercially
>> by Philip Greenspun, before Sun hired Tcl creator Ousterhout, and Tcl
>> disappeared, in favor of Java and then LiveScript/JS.)
>
> I seem to remember hearing that Scheme was one of the 
> inspirations for Python.  That and another language.
>
> -- hendrik

That other language is Dylan, which is also inspired by Scheme.

Brett Gilio

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] project idea: drracket notebook mode

[Neil Van Dyke]

Pasting some clarification from a different thread into this one...

Neil Van Dyke wrote on 12/26/18 5:09 PM:
BTW, to be clear (since it took me a while to unravel the vague and 
changing meanings of Jupyter and IPython the other day)...


What I proposed in another thread here was adding an user interface to 
DrRacket that's inspired by Jupyter Notebook and other notebook 
metaphors from stats tools.


There's also a different possible Jupyter angle for Racket, in which 
Racket is a backend for the Jupyter frontends (in lieu of DrRacket).  
I think that approach would also be useful for some people, and Ryan 
Culpepper is already tackling that one (and I wanted to let him 
publicize it on his schedule).


These two different approaches might interoperate, if the first 
approach also saves a Jupyter ".ipynb" file, and then notebooks files 
could be moved back and forth between DrRacket and Jupyter, and run in 
both.




These are two very different "Jupyter-related/inspired" things being 
talked about, both have merit and uses the other does not, and ideally 
both would be done.


I don't want to get into the incomplete list of pros I've thought 
of so far about each approach, but I think probably people can agree 
that a notebook interface in DrRacket (with all its tools, and its GUI 
app properties) is very different than getting Racket backend in a 
Jupyter Notebook Web browser interface.


The two approaches overlap for unusual use cases like "I just want to 
make a screenshot of *a* notebook interface, and I don't care what 
features it has, nor how it works for different people's workflows".  I 
think they'd each have very different strengths and shortcomings, for 
many/most real-world use cases.


(Not mentioning the IPython kernel backend approach was a glaring 
omission from my initial post, but I was consciously trying to avoid 
confusion, or stepping on Ryan's toes, if he wasn't ready to publicize 
his work like I think it deserves.  I should've known that many helpful 
eagle-eyed people would mention it if I didn't.  Maybe I shouldn't have 
referenced the current popularity of Jupyter Notebook at all, picked a 
likely-familiar older math package notebook metaphor to reference, and 
emphasized the desirability of keeping the DrRacket features, to preempt 
off-message Jupyter mentions or prime an objection handler for them.  
I'm a much better engineer/scientist than I am a marketer, and I'd much 
rather work through this kind of system problem myself than try to 
convince others to do so, so please be patient. :)


--
You received this message because you are subscribed to the Google Groups "Racket 
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] hackernews

[Hendrik Boom]

On Wed, Dec 26, 2018 at 09:51:17AM -0500, Neil Van Dyke wrote:
> 
> Python started out as some guy on Usenet with a reusable extension
> language (Tcl was another, and some RnRS implementations were another)
> -- all 3 of them had interesting innovations and merits. (Tcl got
> popular because of Tk GUIs, and then it has some moments in the sun
> for earlier database-backed Web servers (as opposed to manually-edited
> HTML) while a lot more readable than Perl, and was pushed commercially
> by Philip Greenspun, before Sun hired Tcl creator Ousterhout, and Tcl
> disappeared, in favor of Java and then LiveScript/JS.)

I seem to remember hearing that Scheme was one of the 
inspirations for Python.  That and another language.

-- hendrik

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [racket-users] project idea: drracket notebook mode

[Spencer Florence]

One exists:

https://github.com/rmculpepper/iracket

On Thu, Dec 27, 2018, 12:53 AM Andrew Gwozdziewycz  It seems like the better bang for buck might be implementing a Jupyter
> kernel, and leveraging that ecosystem.
>
> https://github.com/jupyter/jupyter/wiki/Jupyter-kernels
>
> On Dec 20, 2018, at 02:46, Neil Van Dyke  wrote:
>
> If anyone is looking to avoid relatives over the winter holiday season,
> here's an idea for a big feature to add to DrRacket (which I really wish I
> could do myself right now)...
>
> If you've not seen a "notebook" interface, like in Jupyter Notebook and
> some other data science-oriented tools, one way to look at it is like a
> literate programming REPL that can be edited, stored to a file, and
> loaded.  You can also share these notebooks with others, or generate
> formats like HTML or Markdown (such as for blog posts).
>
> The notebook is a document that's a sequence of text cells and code cells,
> and the code cells include the output (e.g., expression results, displayed
> plots) from the last time the code cell was evaluated (if it was).  Each
> code cell also displays a small serial number that indicates in what order
> it was last evaluated (if it has been), which is not necessarily the
> top-to-bottom order of the document while you're working with it.  Of
> course, you can clear this code evaluation and output at any time, and
> cause all the code cells to be evaluated in-order.
>
> IIRC, DrRacket emphasizes the Definitions window over the Interactions
> window (aka REPL), to reduce confusion for students.  I think the confusion
> level of the Notebook interface is somewhere between that of Definitions
> window and a REPL.  So the notebook interface might not be good for new
> students, unless they're already comfortable with the notebook interface
> from other classes.
>
> Implementation-wise... the people here who built DrRacket can correct me
> or say more about this, but it seems DrRacket implementation might already
> include most of the difficult work of implementing a notebook interface.
> The evaluation engine is there, and there's UI for snips in the Interaction
> window, and UI for embedding blocks of other formats in the Definitions
> window.  Maybe combine/adapt that in a new Notebook window, or implement
> this as features of the Definitions window.  Then you can decide whether to
> also implement the JSON save format of Jupyter Notebook, for possible later
> interoperation.  And other things after that, like in-buffer Markdown or
> Scribble rendering of text cells.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>
> --
> You received this message because you are subscribed to the Google Groups
> "Racket Users" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to racket-users+unsubscr...@googlegroups.com.
> For more options, visit https://groups.google.com/d/optout.
>

-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.