Re: [racket-users] detecting a recursive call?

[Hendrik Boom]

On Fri, Aug 09, 2019 at 01:03:17PM -0400, Sam Tobin-Hochstadt wrote:
> This is possible -- the central trick is to maintain information about
> the call stack separately, perhaps by using continuation marks.

Or set a global variable on entry, and reset it on exit.
If on entry the global variable is set (before you set it, of course),
 you've called yourself,  directly of indirectly.

> 
> We (mostly Phil Nguyen) recently built a tool that does this. If you
> take your program, install the "termination" package, and then add:
> 
> (require termination)
> (begin/termination (recur1 0))
> 
> you get this error message:
> 
> possible-non-termination: Recursive call to `#` has
> no obvious descent on any argument
> - Preceding call:
>   * 1st arg: 3
> - Subsequent call:
>   * 1st arg: 6
> 
> We have a paper, here: https://arxiv.org/abs/1808.02101 which goes
> into detail about how it works. The source code is here:
> https://github.com/philnguyen/termination
> 
> Sam
> 
> On Fri, Aug 9, 2019 at 11:58 AM Kees-Jochem Wehrmeijer
>  wrote:
> >
> > Hi,
> >
> > I'm wondering whether it's possible for a function to detect whether it's 
> > being called by itself, possibly indirectly. I want to use this to prevent 
> > endless loops and generate different results in these situations. For 
> > example, imagine I have the following functions:
> >
> > (define (foo loc)
> >   (list
> >(cons loc 'a)
> >(cons (+ loc 1) 'b)
> >(cons (+ loc 2) 'c)))
> >
> > (define (combine a b)
> >   (lambda (loc)
> > (append (a loc) (b (+ loc 3)
> >
> > So I can do:
> > > ((combine foo foo) 0)
> > => '((0 . a) (1 . b) (2 . c) (3 . a) (4 . b) (5 . c))
> >
> > Now, let's say I have these recursive definitions:
> >
> > (define (recur1 loc)
> >   ((combine foo recur2) loc))
> >
> > (define (recur2 loc)
> >   (recur1 loc))
> >
> > Defined in this way, a call to (recur1 0) loops endlessly. I would like it 
> > too return something like
> > > (recur1 0)
> > => '(0 . a) (1 . b) (2 . c) (loop 0))
> >
> > So I was thinking if I could make it work if I could do something like:
> > (define (recur1 loc)
> >   (if (in-recursive-call?)
> >   (list (cons 'loop 0))
> >   ((combine foo recur2) loc)))
> >
> > Is that something that's possible? Is there a better way to do what I want?
> >
> > Thanks,
> > Kees
> >
> > --
> > 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.
> > To view this discussion on the web visit 
> > https://groups.google.com/d/msgid/racket-users/292977cf-7800-453f-9d4b-b6a1ee525287%40googlegroups.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.
> To view this discussion on the web visit 
> https://groups.google.com/d/msgid/racket-users/CAK%3DHD%2Bb0odK1qfox9Ah2umLqKxUhas_GTJUv95Avm536g9ybGg%40mail.gmail.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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/20190809182512.cffth5bwreff5urs%40topoi.pooq.com.

[racket-users] Racket CS Profiler

[Anurag Mendhekar]

Does the profiler work as expected in Racket CS? I'm getting the total time
taken, but the detailed profile has little useful information. If not, Is
there a way to get better profiling information in CS?

Best,

Anurag.

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAHjTuf%3DAJtkg5Oq79%3DfzqstJA0UmiXpNbJGsgXqLPB6q8NviJw%40mail.gmail.com.

Re: [racket-users] Re: GitHub ‘template repository’ functionality

[Stephen De Gabrielle]

Hi Ryan,

On Fri, Aug 9, 2019 at 8:10 PM Ryan Kramer  wrote:

> Thanks Stephen, this looks useful.
>
> I don't understand why you say "I think the template should only have the
> things that `raco pkg new` doesn't do." Wouldn't the intent be that I use
> the template to create my own repo, clone it onto my local machine, and
> then run `raco pkg install`? In that case, I think you would want the stuff
> from `raco pkg new`. (But my knowledge of packages and collections is
> just-enough-to-get-by.)
>

Thats not bad, but the more look at `raco pkg new` the more I realise how
good it is! - It knows I'm the author in addition to the name of the
package and populates the template files accordingly. Some examples below
for the command `raco pkg new orlando`
`new.rkt` is also pretty easy to extend - take a look at the code:
https://github.com/racket/racket/blob/master/racket/collects/pkg/private/new.rkt

The other factors on my mind are;
a) Also GitHub are a big organisation (we don't even rate a .gitignore
template. ) - relying on a giant who doesn't even know you exist isn't nice
position.
b) Not everyone wants to use GitHub. There are other providers. e.g. GitLab
is also good. Some racketeers have very good reasons to not use GitHub.

I think a good template that learns from my mistakes would..
..include generic git configuration (.gitignore)
..have GitHub/Lab/etc versions activate relevant features for those
platforms  (.github .gitlab etc.)
..have a readme that tells you how to; add raco to your $path, run `raco
pkg new  `, register on https://pkgs.racket-lang.org etc.
(similar  guidance is already in place in the `main.rkt` as generated by `raco
pkg new` )

I recently struggled converting a repository from a single to a
> multi-collection package. (And I still have some learning and cleanup to
> do.) It might be nice to have a template for a simple multi-collection repo
> also. Maybe with lib, doc, and test collections? On the other hand, maybe
> multi-collection packages are too different for a template to make sense.
>

I think a template for each is good idea. Maybe you could use your
multi-collection package as a starting point?
I'm not sure how `new.rkt` could be extended to support this - but making a
template can help others in the meantime, and provides a sketch of what you
would want `raco pkg new multi` to do in the future. (maybe templates for
web & gui apps too?)

Kind regards,

Stephen

examples of output of  `raco pkg new orlando`:

> #lang scribble/manual
> @require[@for-label[orlando
> racket/base]]
> @title{orlando}
> @author{spdegabrielle}
> @defmodule[orlando]
> Package Description Here



> #lang info
> (define collection "orlando")
> (define deps '("base"))
> (define build-deps '("scribble-lib" "racket-doc" "rackunit-lib"))
> (define scribblings '(("scribblings/orlando.scrbl" (
> (define pkg-desc "Description Here")
> (define version "0.0")
> (define pkg-authors '(spdegabrielle))

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAGHj7-JRJSgdY_K%3D_3EQ7yxiKXRW6ensGExNCRpHyxJPN1rTTw%40mail.gmail.com.

Re: [racket-users] detecting a recursive call?

[Gustavo Massaccesi]

If you don't want to use the package or you want other criteria for
stooping, I think the correct way to do this are continuation marks, but an
easier but more inefficient way is using a parameter (so it is thread safe).

;-
#lang racket
(define recursion-level (make-parameter 0))

(define (f x)
  (sleep (* .1 (random)))
  (cond
[(<= (recursion-level) 5)
 (parameterize ([recursion-level (add1 (recursion-level))])
   (displayln (list (recursion-level) x))
   (f (* x 2)))]
[else
 (displayln (list "too many recursions" x))]))

(thread (lambda () (f 10)))
(f 1)
; -

Gustavo

On Fri, Aug 9, 2019 at 2:03 PM Sam Tobin-Hochstadt 
wrote:

> This is possible -- the central trick is to maintain information about
> the call stack separately, perhaps by using continuation marks.
>
> We (mostly Phil Nguyen) recently built a tool that does this. If you
> take your program, install the "termination" package, and then add:
>
> (require termination)
> (begin/termination (recur1 0))
>
> you get this error message:
>
> possible-non-termination: Recursive call to `#` has
> no obvious descent on any argument
> - Preceding call:
>   * 1st arg: 3
> - Subsequent call:
>   * 1st arg: 6
>
> We have a paper, here: https://arxiv.org/abs/1808.02101 which goes
> into detail about how it works. The source code is here:
> https://github.com/philnguyen/termination
>
> Sam
>
> On Fri, Aug 9, 2019 at 11:58 AM Kees-Jochem Wehrmeijer
>  wrote:
> >
> > Hi,
> >
> > I'm wondering whether it's possible for a function to detect whether
> it's being called by itself, possibly indirectly. I want to use this to
> prevent endless loops and generate different results in these situations.
> For example, imagine I have the following functions:
> >
> > (define (foo loc)
> >   (list
> >(cons loc 'a)
> >(cons (+ loc 1) 'b)
> >(cons (+ loc 2) 'c)))
> >
> > (define (combine a b)
> >   (lambda (loc)
> > (append (a loc) (b (+ loc 3)
> >
> > So I can do:
> > > ((combine foo foo) 0)
> > => '((0 . a) (1 . b) (2 . c) (3 . a) (4 . b) (5 . c))
> >
> > Now, let's say I have these recursive definitions:
> >
> > (define (recur1 loc)
> >   ((combine foo recur2) loc))
> >
> > (define (recur2 loc)
> >   (recur1 loc))
> >
> > Defined in this way, a call to (recur1 0) loops endlessly. I would like
> it too return something like
> > > (recur1 0)
> > => '(0 . a) (1 . b) (2 . c) (loop 0))
> >
> > So I was thinking if I could make it work if I could do something like:
> > (define (recur1 loc)
> >   (if (in-recursive-call?)
> >   (list (cons 'loop 0))
> >   ((combine foo recur2) loc)))
> >
> > Is that something that's possible? Is there a better way to do what I
> want?
> >
> > Thanks,
> > Kees
> >
> > --
> > 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.
> > To view this discussion on the web visit
> https://groups.google.com/d/msgid/racket-users/292977cf-7800-453f-9d4b-b6a1ee525287%40googlegroups.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.
> To view this discussion on the web visit
> https://groups.google.com/d/msgid/racket-users/CAK%3DHD%2Bb0odK1qfox9Ah2umLqKxUhas_GTJUv95Avm536g9ybGg%40mail.gmail.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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAPaha9MPK2A5jBD4GVmtOZrSjb24tDD6-WQKPBCPuSe_Yiq6Fw%40mail.gmail.com.

[racket-users] Re: GitHub ‘template repository’ functionality

[Ryan Kramer]

Thanks Stephen, this looks useful.

I don't understand why you say "I think the template should only have the 
things that `raco pkg new` doesn't do." Wouldn't the intent be that I use 
the template to create my own repo, clone it onto my local machine, and 
then run `raco pkg install`? In that case, I think you would want the stuff 
from `raco pkg new`. (But my knowledge of packages and collections is 
just-enough-to-get-by.)

I recently struggled converting a repository from a single to a 
multi-collection package. (And I still have some learning and cleanup to 
do.) It might be nice to have a template for a simple multi-collection repo 
also. Maybe with lib, doc, and test collections? On the other hand, maybe 
multi-collection packages are too different for a template to make sense.

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/7827f4e3-af4b-4d0b-b12b-d97efbae07db%40googlegroups.com.

Re: [racket-users] detecting a recursive call?

[Sam Tobin-Hochstadt]

This is possible -- the central trick is to maintain information about
the call stack separately, perhaps by using continuation marks.

We (mostly Phil Nguyen) recently built a tool that does this. If you
take your program, install the "termination" package, and then add:

(require termination)
(begin/termination (recur1 0))

you get this error message:

possible-non-termination: Recursive call to `#` has
no obvious descent on any argument
- Preceding call:
  * 1st arg: 3
- Subsequent call:
  * 1st arg: 6

We have a paper, here: https://arxiv.org/abs/1808.02101 which goes
into detail about how it works. The source code is here:
https://github.com/philnguyen/termination

Sam

On Fri, Aug 9, 2019 at 11:58 AM Kees-Jochem Wehrmeijer
 wrote:
>
> Hi,
>
> I'm wondering whether it's possible for a function to detect whether it's 
> being called by itself, possibly indirectly. I want to use this to prevent 
> endless loops and generate different results in these situations. For 
> example, imagine I have the following functions:
>
> (define (foo loc)
>   (list
>(cons loc 'a)
>(cons (+ loc 1) 'b)
>(cons (+ loc 2) 'c)))
>
> (define (combine a b)
>   (lambda (loc)
> (append (a loc) (b (+ loc 3)
>
> So I can do:
> > ((combine foo foo) 0)
> => '((0 . a) (1 . b) (2 . c) (3 . a) (4 . b) (5 . c))
>
> Now, let's say I have these recursive definitions:
>
> (define (recur1 loc)
>   ((combine foo recur2) loc))
>
> (define (recur2 loc)
>   (recur1 loc))
>
> Defined in this way, a call to (recur1 0) loops endlessly. I would like it 
> too return something like
> > (recur1 0)
> => '(0 . a) (1 . b) (2 . c) (loop 0))
>
> So I was thinking if I could make it work if I could do something like:
> (define (recur1 loc)
>   (if (in-recursive-call?)
>   (list (cons 'loop 0))
>   ((combine foo recur2) loc)))
>
> Is that something that's possible? Is there a better way to do what I want?
>
> Thanks,
> Kees
>
> --
> 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.
> To view this discussion on the web visit 
> https://groups.google.com/d/msgid/racket-users/292977cf-7800-453f-9d4b-b6a1ee525287%40googlegroups.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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAK%3DHD%2Bb0odK1qfox9Ah2umLqKxUhas_GTJUv95Avm536g9ybGg%40mail.gmail.com.

[racket-users] Re: Racket v7.4

['Joel Dueck' via Racket Users]

On Win10 / Firefox the "variant" selector does not appear for me, I'm not 
sure why yet. I don't have any errors in the console.

I can see it just fine on Win10 / Chrome, macOS / Safari, and macOS / 
Firefox.

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/dfe730fb-b3a5-4e94-badb-875749324362%40googlegroups.com.

[racket-users] detecting a recursive call?

[Kees-Jochem Wehrmeijer]

Hi,

I'm wondering whether it's possible for a function to detect whether it's 
being called by itself, possibly indirectly. I want to use this to prevent 
endless loops and generate different results in these situations. For 
example, imagine I have the following functions:

(define (foo loc)
  (list
   (cons loc 'a)
   (cons (+ loc 1) 'b)
   (cons (+ loc 2) 'c)))

(define (combine a b)
  (lambda (loc)
(append (a loc) (b (+ loc 3)

So I can do:
> ((combine foo foo) 0)
=> '((0 . a) (1 . b) (2 . c) (3 . a) (4 . b) (5 . c))

Now, let's say I have these recursive definitions:

(define (recur1 loc)
  ((combine foo recur2) loc))

(define (recur2 loc)
  (recur1 loc))

Defined in this way, a call to (recur1 0) loops endlessly. I would like it 
too return something like
> (recur1 0)
=> '(0 . a) (1 . b) (2 . c) (loop 0))

So I was thinking if I could make it work if I could do something like:
(define (recur1 loc)
  (if (in-recursive-call?)
  (list (cons 'loop 0))
  ((combine foo recur2) loc)))

Is that something that's possible? Is there a better way to do what I want?

Thanks,
Kees

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/292977cf-7800-453f-9d4b-b6a1ee525287%40googlegroups.com.

Re: [racket-users] Racket v7.4

[Bruce O'Neel]

Hi,  
  
Fantastic!  
  
It looks as if the CS builds are only x86-64, right?  Are there plans to add 
others, say arm32 and arm64?  
  
Thanks very much.  
  
cheers  
  
bruce  

> Racket version 7.4 is now available from  
>   
> [https://racket-lang.org/](https://racket-lang.org/)  
>   
>  With this 7.4 release, we are making Racket CS available, a beta version  
>  of the Racket on Chez Scheme implementation. Racket CS is "beta"  
>  quality for the v7.4 release. It works well enough to be worth trying,  
>  but there are likely too many lingering problems for a project to switch  
>  to Racket CS for production use at this time. We encourage you to kick  
>  the tires of the new CS releases, and to help push this project forward  
>  by reporting any problems that you find.  
>   
>  - Racket CS is available as a download option. To download Racket CS,  
>  select "CS" instead of "regular" from the "Variant" popup menu.  
>   
>  - Single-precision floating-point literals, a.k.a. single-flonums, are  
>  no longer supported by default.  
>   
>  This is a backward-incompatible change, but the use of single-flonums  
>  appears to be rare. Since Racket CS does not support single-flonums,  
>  disabling single-flonums by default smooths the transition from regular  
>  Racket and Racket CS.  
>   
>  The `read-single-flonum` parameter can be set to #t to enable reading  
>  single-flonum literals, but a better strategy in most cases is to use  
>  `real->single-flonum` when `single-flonum-available?` reports #t or  
>  when `single-flonum?` reports #t for a value (which implies that  
>  single-flonums must be supported). Where single-flonums are supported,  
>  Racket's compiler will fold a call of `real->single-flonum` on a  
>  literal number to a constant single-flonum value.  
>   
>  - New compilation flags including --disable-generations and --enable-ubsan  
>  provide better support for alternative  
>  architectures.  
>   
>  - The 2htdp/universe teachpack supports an event log window for big-bang.  
>  With this option, students can inspect the events that big-bang handled,  
>  plus their payload. The event log includes messages from external  
>  sources.  
>   
>  The following people contributed to this release: Alex Knauth, Alexander  
>  B. McLin, Alexis King, Andreas Düring, Asumu Takikawa, Atharva Raykar,  
>  Ben Greenman, Benjamin Yeung, Dmitry Moskowski, Fred Fu, Gustavo  
>  Massaccesi, Ilnar Salimzianov, Jason Hemann, Jay McCarthy, Jesse A. Tov,  
>  Jesse Alama, John Clements, Leif Andersen, Lukas Lazarek, Matthew Flatt,  
>  Matthias Felleisen, Mike Sperber, Morgan Lemmer-Webber, Noah W M, Paulo  
>  Matos, Philip McGrath, Robby Findler, Rodrigo, Roman Klochkov, Ryan  
>  Culpepper, Sam Tobin-Hochstadt, Simon 'Sze' L. Schlee, Sorawee  
>  Porncharoenwase, Spencer Florence, Stephan Renatus, Stephen Chang,  
>  Stephen De Gabrielle, Thomas Dickerson, Vincent St-Amour, and yjqww6  
>   
>  Feedback Welcome  
>   
>   
>   
>  --  
>  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](mailto:racket-users+unsubscr...@googlegroups.com).
>   
>  To view this discussion on the web visit 
> [https://groups.google.com/d/msgid/racket-users/e6f4bc0f-bc9a-4f6c-908e-6087bc5e6d50%40mtasv.net](https://groups.google.com/d/msgid/racket-users/e6f4bc0f-bc9a-4f6c-908e-6087bc5e6d50%40mtasv.net).
  

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/1565360931-788f7c51fe836e948c6c682d3f55e0f0%40pckswarms.ch.

Re: [racket-users] Re: Do custodians shutdown when Racket exits?

[George Neuner]

On 8/8/2019 7:34 AM, Tony Garnock-Jones wrote:
On Tue, 6 Aug 2019 at 21:15, George Neuner > wrote:


Sockets belonging to the crashed program are in a "half-closed"
state - unable to send, but still able to receive.  If you look in
netstat you'll find their status is stuck in TIME_WAIT or in SYN
or SYN/ACK. There is a delay in cleaning up such "half-closed"
sockets.  The delay is (derived from) a system wide parameter, and
typically the wait time is on the order of 180 seconds.


Those states only apply to TCP sockets; UDP is stateless (in that 
way). It still seems quite peculiar to me that UDP sockets should 
outlive their process, under any circumstances. Perhaps it's a 
Mac-specific thing? I wonder if it's a bug or if it's for some reason.


That's not exactly true - UDP is "stateless" only when compared to streams.

The datagram protocol is itself a state machine, and there are a number 
of modes that UDP sockets can be in, including "half-closed":  e.g., you 
can call *shutdown* on a UDP socket to individually block either its 
send or receive capabilities. Also, you can call *connect* on a UDP 
socket and then use *read*, *write*, *send* and *recv* in lieu of the 
stateless *sendto* / *sendmsg* or *recvfrom* / *recvmsg*. I.e. there is 
both the notion of "unconnected" and "connected" UDP, although 
"connected" means something different here than it does with TCP.


I've been programming so long that most of my sources are dead trees on 
a bookshelf.  Google is not being particularly helpful just now in 
finding a comprehensive socket reference to cite ... unless you want PDF 
books or the original RFCs.  It seems much of the online information on 
UDP  is in bits and pieces, and most of it deals only with "unconnected" 
use.  But you can search "*connected udp*" for a few starting points.


I'm not sure what, if anything, netstat can show for "connected" or 
"half-closed" UDP sockets -  I'm don't think network stack makes any of 
that information available to be queried.  It's much more concerned with 
the more complex TCP status.


George

--
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/639b088b-ef38-bdf9-0302-96818dcf3bf9%40comcast.net.

[racket-users] Article on racket

[Stephen De Gabrielle]

FYI
Racket: Lisp for learning
https://lwn.net/SubscriberLink/795385/2fe3529b76fae7c9/

-- 


-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAGHj7-LwbAdUVYQt977%2BPCwpH50YDfRDtpMpu%3Ds5SHcQTmti1Q%40mail.gmail.com.

[racket-users] Fwd: Racket featured in LWN

[Alexander Shopov]

-- Forwarded message -
From: Alexander Shopov 
Date: Fri, 9 Aug 2019, 11:37
Subject: Racket featured in LWN
To: Racket Users 


This week's edition of Linux Weekly News features an article about Racket
by Jake Edge:
Racket: Lisp for learning
Have a look:
https://lwn.net/SubscriberLink/795385/2fe3529b76fae7c9/

Kind regards:
al_shopov

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAP6f5M%3D3b_UtFMLPBpY_%3Dk8ikjYG_Js6Ohewk54%2BUvaCbSVYhw%40mail.gmail.com.

[racket-users] Racket featured in LWN

[Alexander Shopov]

This week's edition of Linux Weekly News features an article about Racket
by Jake Edge:
Racket: Lisp for learning
Have a look:
https://lwn.net/SubscriberLink/795385/2fe3529b76fae7c9/

Kind regards:
al_shopov

-- 
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.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/racket-users/CAP6f5MkniaYd66Gq4DdEa%3DCo6O5cRaar5r4FnbCpA6Dr0wPb7g%40mail.gmail.com.