Hello,
I'm working with a student on creating a super high resolution image using
racket (limited only by imagemagick's ability to paste images together). To do
this we are breaking the rendering process into many smaller images that will
be rendered individually by separate machines and reassembled by a server.
Each image is processed individually as a byte string and saved to a file. We
started to use the universe package and built a server to "serve" individual
zooms to clients which would then respond with a byte string which the server
saved to an image file to be compiled later by imagemagick. The problem we ran
into was that the server displays the messages passed back and forth and
displaying the byte strings is too slow. Is there a way to depress the display
of information in messages? I had trouble finding it in the documentation.
Thanks in advance for your help!
Best,
Dan Anderson
On Tuesday, February 11, 2014 7:14 AM, "[email protected]"
<[email protected]> wrote:
Send users mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://lists.racket-lang.org/users/listinfo
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of users digest..."
[Racket Users list:
http://lists.racket-lang.org/users ]
Today's Topics:
1. Re: Y combinator (Matthias Felleisen)
2. Re: Y combinator (Matthias Felleisen)
3. Re: Y combinator (Matthew Johnson)
4. Re: Y combinator (Matthias Felleisen)
5. Re: Is racket suitable for such a project? (Neil Van Dyke)
----------------------------------------------------------------------
Message: 1
Date: Tue, 11 Feb 2014 09:37:40 -0500
From: Matthias Felleisen <[email protected]>
To: Matthew Johnson <[email protected]>
Cc: "[email protected]" <[email protected]>,
"[email protected]" <[email protected]>
Subject: Re: [racket] Y combinator
Message-ID: <[email protected]>
Content-Type: text/plain; charset=iso-8859-1
On Feb 11, 2014, at 12:48 AM, Matthew Johnson <[email protected]> wrote:
> I am still a little unclear. Is this a logical result, or a result of the
> evaluator's rules? Or are they the same thing?
They are the same thing. To calculate with the Racket that you see in the
book/derivation, use this rule:
( (lambda (x) e) V ) ~ e with all [free] occurrences of x replaced by V
[This is the rule you learn in pre-algebra, with the 'free' needed here
because
variables can occur at more places than in pre-algebra.] Using this rule, plus
simple car/cdr/cons/+1 rules, you can confirm every step in the derivation. As
it
turns out, the compiler implements this rule totally faithfully BUT instead of
copying actual code it "copies" references to code by moving things from
registers
to registers. Because the two are equivalent, a programmer can use the above
rule to think about code and the compiler writer (one among 10,000s of language
users) is the only one who has to keep references, registers, and replication
in mind (kind of).
-- Matthias
------------------------------
Message: 2
Date: Tue, 11 Feb 2014 10:01:43 -0500
From: Matthias Felleisen <[email protected]>
To: Matthew Johnson <[email protected]>
Cc: "[email protected] Users" <[email protected]>
Subject: Re: [racket] Y combinator
Message-ID: <[email protected]>
Content-Type: text/plain; charset=iso-8859-1
Ouch, I forgot to explain V. NO, you canNOT replace x with arbitrary
expressions. You may use ONLY VALUES (V for Value). In this context a value is
one of: #t/#f, number, or a lambda expression. -- Matthias
On Feb 11, 2014, at 9:50 AM, Matthew Johnson <[email protected]> wrote:
> The general form: ( (lambda (x) e) V) ~ e with all [free] x replaced by V
>
> In concrete terms means: ( (lambda (x) (* x y) 2) ~ (* 2 y) ?
>
> I figure best to be sure now.
>
> Thanks and best regards
>
> matt johnson
>
>
> On 11/02/2014, at 3:35 PM, Matthias Felleisen <[email protected]> wrote:
>
>>
>> On Feb 11, 2014, at 12:48 AM, Matthew Johnson <[email protected]> wrote:
>>
>>> I am still a little unclear. Is this a logical result, or a result of the
>>> evaluator's rules? Or are they the same thing?
>>
>>
>> They are the same thing. To calculate with the Racket that you see in the
>> book/derivation, use this rule:
>>
>> ( (lambda (x) e) V ) ~ e with all [free] occurrences of x replaced by V
>>
>> [This is the rule you learn in pre-algebra, with the 'free' needed here
>> because
>> variables can occur at more places than in pre-algebra.] Using this rule,
>> plus
>> simple car/cdr/cons/+1 rules, you can confirm every step in the derivation.
>> As it
>> turns out, the compiler implements this rule totally faithfully BUT instead
>> of
>> copying actual code it "copies" references to code by moving things from
>> registers
>> to registers. Because the two are equivalent, a programmer can use the above
>> rule to think about code and the compiler writer (one among 10,000s of
>> language
>> users) is the only one who has to keep references, registers, and replication
>> in mind (kind of).
>>
>> -- Matthias
>>
------------------------------
Message: 3
Date: Tue, 11 Feb 2014 16:06:03 +0100
From: Matthew Johnson <[email protected]>
To: Matthias Felleisen <[email protected]>
Cc: "[email protected] Users" <[email protected]>
Subject: Re: [racket] Y combinator
Message-ID: <3538474613101379763@unknownmsgid>
Content-Type: text/plain; charset=ISO-8859-1
So in terms of my example:
We have the general form: ( (lambda (x) e) V) ~ e with all [free] x
replaced by V
And for V <-- 2 :: ( (lambda (x) (* x y) 2) ~ (* 2 y) ?
But for V <-- z^2 :: error and NOT ~ (* (* z z) y) ?
Thanks
On 11/02/2014, at 3:59 PM, Matthias Felleisen <[email protected]> wrote:
>
>
> Ouch, I forgot to explain V. NO, you canNOT replace x with arbitrary
> expressions. You may use ONLY VALUES (V for Value). In this context a value
> is one of: #t/#f, number, or a lambda expression. -- Matthias
>
>
>
>
>
> On Feb 11, 2014, at 9:50 AM, Matthew Johnson <[email protected]> wrote:
>
>> The general form: ( (lambda (x) e) V) ~ e with all [free] x replaced by V
>>
>> In concrete terms means: ( (lambda (x) (* x y) 2) ~ (* 2 y) ?
>>
>> I figure best to be sure now.
>>
>> Thanks and best regards
>>
>> matt johnson
>>
>>
>> On 11/02/2014, at 3:35 PM, Matthias Felleisen <[email protected]> wrote:
>>
>>>
>>> On Feb 11, 2014, at 12:48 AM, Matthew Johnson <[email protected]> wrote:
>>>
>>>> I am still a little unclear. Is this a logical result, or a result of the
>>>> evaluator's rules? Or are they the same thing?
>>>
>>>
>>> They are the same thing. To calculate with the Racket that you see in the
>>> book/derivation, use this rule:
>>>
>>> ( (lambda (x) e) V ) ~ e with all [free] occurrences of x replaced by V
>>>
>>> [This is the rule you learn in pre-algebra, with the 'free' needed here
>>> because
>>> variables can occur at more places than in pre-algebra.] Using this rule,
>>> plus
>>> simple car/cdr/cons/+1 rules, you can confirm every step in the derivation.
>>> As it
>>> turns out, the compiler implements this rule totally faithfully BUT instead
>>> of
>>> copying actual code it "copies" references to code by moving things from
>>> registers
>>> to registers. Because the two are equivalent, a programmer can use the above
>>> rule to think about code and the compiler writer (one among 10,000s of
>>> language
>>> users) is the only one who has to keep references, registers, and
>>> replication
>>> in mind (kind of).
>>>
>>> -- Matthias
>
------------------------------
Message: 4
Date: Tue, 11 Feb 2014 10:09:44 -0500
From: Matthias Felleisen <[email protected]>
To: Matthew Johnson <[email protected]>
Cc: "[email protected] Users" <[email protected]>
Subject: Re: [racket] Y combinator
Message-ID: <[email protected]>
Content-Type: text/plain; charset=iso-8859-1
On Feb 11, 2014, at 10:06 AM, Matthew Johnson <[email protected]> wrote:
> So in terms of my example:
>
> We have the general form: ( (lambda (x) e) V) ~ e with all [free] x
> replaced by V
>
> And for V <-- 2 :: ( (lambda (x) (* x y) 2) ~ (* 2 y) ?
>
> But for V <-- z^2 :: error and NOT ~ (* (* z z) y) ?
Not error. It just doesn't reduce. But usually this doesn't happen, z will have
been replaced with a value.
>
> Thanks
>
> On 11/02/2014, at 3:59 PM, Matthias Felleisen <[email protected]> wrote:
>
>>
>>
>> Ouch, I forgot to explain V. NO, you canNOT replace x with arbitrary
>> expressions. You may use ONLY VALUES (V for Value). In this context a value
>> is one of: #t/#f, number, or a lambda expression. -- Matthias
>>
>>
>>
>>
>>
>> On Feb 11, 2014, at 9:50 AM, Matthew Johnson <[email protected]> wrote:
>>
>>> The general form: ( (lambda (x) e) V) ~ e with all [free] x replaced by V
>>>
>>> In concrete terms means: ( (lambda (x) (* x y) 2) ~ (* 2 y) ?
>>>
>>> I figure best to be sure now.
>>>
>>> Thanks and best regards
>>>
>>> matt johnson
>>>
>>>
>>> On 11/02/2014, at 3:35 PM, Matthias Felleisen <[email protected]> wrote:
>>>
>>>>
>>>> On Feb 11, 2014, at 12:48 AM, Matthew Johnson <[email protected]> wrote:
>>>>
>>>>> I am still a little unclear. Is this a logical result, or a result of
>>>>> the evaluator's rules? Or are they the same thing?
>>>>
>>>>
>>>> They are the same thing. To calculate with the Racket that you see in the
>>>> book/derivation, use this rule:
>>>>
>>>> ( (lambda (x) e) V ) ~ e with all [free] occurrences of x replaced by V
>>>>
>>>> [This is the rule you learn in pre-algebra, with the 'free' needed here
>>>> because
>>>> variables can occur at more places than in pre-algebra.] Using this rule,
>>>> plus
>>>> simple car/cdr/cons/+1 rules, you can confirm every step in the
>>>> derivation. As it
>>>> turns out, the compiler implements this rule totally faithfully BUT
>>>> instead of
>>>> copying actual code it "copies" references to code by moving things from
>>>> registers
>>>> to registers. Because the two are equivalent, a programmer can use the
>>>> above
>>>> rule to think about code and the compiler writer (one among 10,000s of
>>>> language
>>>> users) is the only one who has to keep references, registers, and
>>>> replication
>>>> in mind (kind of).
>>>>
>>>> -- Matthias
>>
------------------------------
Message: 5
Date: Tue, 11 Feb 2014 10:11:59 -0500
From: Neil Van Dyke <[email protected]>
To: Yuhao Dong <[email protected]>
Cc: [email protected]
Subject: Re: [racket] Is racket suitable for such a project?
Message-ID: <[email protected]>
Content-Type: text/plain; charset=UTF-8; format=flowed
I can't answer the question in the Subject header off-the-cuff, but I
can comment on some of the details...
For an onion router that has to handle lots of traffic at high speed, my
first guess would be C or maybe C++ (not Go or Java), though I can
appreciate wanting a higher-level language for this task.
I might also look at Erlang.
I would consider Python only if the project involves huge numbers of
people running onion nodes, and you want them to be able to inspect the
software themselves. Python is far from perfect for this task, but it
would be good in that large numbers of people can read it, and a better
overall fit than JS.
If you want to do it in Racket, also take a look at Gambit C, which is
my Scheme-y backup if I ever need lots of threads.
If you want to get creative, you might see whether you build this from
domain-specific languages in Racket, but have Racket target C code.
Like Pre-Scheme with DSLs. (Also, going to a hardware description
language from DSLs.)
"#lang racket" is for demos, IMHO; I *always* use "#lang racket/base"
for any code that's not a demo.
A tree-shaker like you suggest might still be appropriate even with
"racket/base", mainly if one wants to put this on a low-space device
like OpenWRT hardware. (Just last night, I was trying to decide whether
I wanted to fit the Linux kernel plus Racket and an app in the 256MB RAM
of the Kindle 3.)
If you want to spread your Racket threads across CPUs/cores, then, yes,
I would look at Racket places as well as homebrew worker threads.
The Racket VM startup time is longer than it used to be, and I no longer
use it often as a quick command-line calculator. (If filesystem and
libraries aren't in Linux caches, it's almost 4 seconds before REPL
prompt on my workstation.) That might not have to be a problem for an
onion-router, however, even if you're starting up lots of processes
(since you might be able to start worker processes before they're needed).
If you're finding Racket run time (not startup time) sometimes slower
than Python, it's possible, but I'm wondering whether the respective
implementations of your code have been hand-optimized.
Good luck with your project.
Neil V,
Yuhao Dong wrote at 02/10/2014 06:49 PM:
> Hi,
>
> I'm trying to decide between Racket and Go on writing my onion-routing
> system inspired by Tor. Basically, a network server, involving lots of
> long-lived connections that often pass large amounts of data. The thing
> needs to be super scalable; I often find that these servers, although
> network servers, often become CPU-bound doing encryption and
> encapsulation of protocols, so I do have experience that this is not
> "premature optimization"!
>
> Go seems to be the go-to (pun intended) for scalable network things. It
> has super cheap threads, is statically compiled (easy to deploy to lots
> of machines), and apparently uses little memory and runs fast. However,
> after writing some low-level transports in Go, I found a few things I
> gripe about but seem to be unsolvable:
>
> - Go doesn't have exceptions. This means checking errors over and over.
> - Go uses lightweight user threads like Racket ("goroutines"), but
> isn't fully non-blocking under the hood for I/O. Thus some I/O
> operations actually spawn a kernel thread, and then kill it when the
> operation is done. This is unacceptable for my use case.
> - Go isn't as fast as I imagined. My program is still CPU-bound at
> around 40 MB/s, and that's just counting pushing zeroes through the
> lowest-level transport protocol.
> - Go's garbage collector is naive stop-the-world mark-and-sweep. My
> program keeps a large amount of state, and constantly pushes data and
> accepts connections. The mark-and-sweep process can take as much as 20
> seconds on large heaps, severly impacting user experience. Since the GC
> is nonmoving, heap fragmentation is also an issue. I searched around a
> bit, and it seems that "buffer reuse" is a thing in Go. Ugh.
>
> So I decided to take Racket, namely Typed Racket, a spin. I like it a
> lot, it's my favorite language after all, and especially I like the fact
> that I can use macros to simplify verbose patterns of code. DrRacket's
> REPL is also very helpful. I also find that Racket is much more
> performant than I imagined (I used to think of it as a Python-type slow
> scripting language). However, there are a few gripes I have, but seeing
> how flexible Racket is, I think they might be solvable:
>
> - Racket threads don't seem to be able to utilize multiple CPU cores.
> Is there an idiomatic way to, say, form a pool of places and push
> threads to them? I imagine sharing data is very messy?
> - The Racket VM is huuuuuuge, both on disk and in memory.
> Infuriatingly, using #lang racket seems to import every single #lang
> racket library into the memory space, and when I raco dist my program,
> every single library gets packaged. I know this sounds like whining, but
> why can't some sort of analysis phase be applied where only the
> libraries actually required for the program to run are loaded?
> - Racket doesn't seem to be able to call raw C code or machine code in
> static libraries, instead requiring the code be compiled into a library.
> Is this related to the fact that Racket is run in a VM rather than
> compiled to machine code?
> - Some things in racket are pathologically slow. As an example, try
> implementing a cipher with loops and array indices and bytestrings. It
> will end up orders of magnitude slower than, say, C or Go or Java, or
> sometimes even Python.
>
> Are there solutions to these problems? These aren't showstoppers by any
> means, but could finally end my endless dilemma between the two langs :)
>
> Thanks!
> Yuhao Dong
>
>
End of users Digest, Vol 102, Issue 31
**************************************____________________
Racket Users list:
http://lists.racket-lang.org/users
