Racket 7.3

Emacs has a decent Racket mode with most of the functionality of DrRacket.

Do Naughty Dog still use Racket? Anyone from there able to give some insight into what tools/dev environment they use there?

A Racket language server would be great. I wonder if some DrRacket internals could be spun off.

VS Code has a pretty good one

https://marketplace.visualstudio.com/items?itemName=evzen-wy...

See http://blog.racket-lang.org/2019/01/racket-on-chez-status.ht... and scroll down to “Performance of Compiled Code.” That was back in January, so things may be even better now.

Is it the general Scheme syntax-rules macros that you're struggling with? Or something unique to Racket? (which I haven't used)

If it's the former, I found this little article helpful when I was new to Scheme:

http://www.willdonnelly.net/blog/scheme-syntax-rules/

Getting rid of C dependency and bootstrap Racket in Scheme.

Try out this guide perhaps: http://www.greghendershott.com/fear-of-macros/

A few people exist who are genuinely able to use Racket macros, but they all have a PhD in CS.

As opposed to the larger group who think they understand them. I was once in that group, but now I've just given up.

> And yet I'm still too stupid to understand the macro system. Oh well.

This talk[0] by Robby Findler helped me a ton when I was first learning about macros in Racket. I've found that the best way to learn, though, is by doing: when you find a use case for a macro, figure out how to do that particular thing and, slowly but surely, things will start to click.

[0]: https://www.youtube.com/watch?v=hFlIl0Zo234

For the macros, I prefer to recommend to start with very straightforward macros that use `define-syntax-rule`. For example

  #lang racket
  
  (define-syntax-rule (run3times code ...)
    (begin
      (begin code ...)
      (begin code ...)
      (begin code ...)))
  
  (define x 0)
  
  (run3times
    (set! x (add1 x))
    (display x))      ; shows ==> 123

As other comment said, you have to find some good opportunity to use a simple macro.

(In this case, it is better to use the build-in `for`. Actually, `for` is defined in a macro, it is not part of the internal "secret" low level language.)

Once you are confident and you grok the difference between a macro and a function, you can try the other ways to define macros. These other ways are more flexible and can make weirder macros, and have better support when the macro is used wrongly. There are good links in the sibling comments.

Another way to learn about all this stuff from the experts themselves is Racket School: https://school.racket-lang.org/

LambdaNative is a cross-platform development environment written in Scheme, supporting Android, iOS, BlackBerry 10, OS X, Linux, Windows, OpenBSD, NetBSD, FreeBSD and OpenWrt.

http://www.lambdanative.org/

Racket does tick some of those boxes:

* it has support for OS-level threads via places[0]

* it can produce binary distributions via `raco distribute`[1] by packing together the interpreter and your compiled code into a single executable

* while the current implementation is based on a bytecode-compiler and VM, I believe the Chez implementation actually compiles to native code (although the whole process is transparent to the user)

* it is possible to run Racket on ARM devices, in fact there was a recent thread[2] about that on the mailing list

I realize this isn't 100% what you're looking for, but Racket does come with many nice features. Alternatively, you might also want to take a look at CHICKEN Scheme[3].

[0]: https://docs.racket-lang.org/guide/parallelism.html#%28part....

[1]: https://docs.racket-lang.org/raco/exe-dist.html

[2]: https://groups.google.com/forum/#!topic/racket-users/YEajWJe...

[3]: https://call-cc.org/

It depends upon what you mean by slow. Typed Racket code compiles more slowly than normal Racket code, but should run about as fast or faster (for a small set of specifically-typed code[0]).

[0]: https://docs.racket-lang.org/ts-guide/optimization.html

Typed racket isn't slow (as far as scripting languages go). Maybe you're thinking of Racket's "contract" system?

AFAIK typed racket does type-checking during compilation (via raco); the resulting code is no slower than normal Racket, although I'm not sure if it's faster either.

The contract system is different; it works on normal, untyped Racket code and performs checks at runtime; similar to using Python decorators to check the input and output of a function. This slows things down, so it's recommended to only check things at module boundaries. For example:

    #lang racket
    (require racket/contract)
    (require racket/match)
    (provide factorial)

    (define/contract (factorial n)
      (-> exact-nonnegative-integer?
          exact-nonnegative-integer?)
      (fact n))

    (define (fact n)
      (match n
        [0 1]
        [_ (* n (fact (- n 1)))]))

This module exposes the `factorial` function, which checks (at runtime) whether its argument and return value are non-negative integers (i.e. 0, 1, 2, ...). The actual calculation is done by the `fact` function, which is private and doesn't do any checks. If we don't separate the checks from the calculation, we would end up running the checks on every recursive call, which would slow things down a lot.

As far as I'm aware, Racket's gradual typing is done by contracts at the interface between typed and untyped code. Hence it's not that typed racket is slow, it's that passing untyped values into typed functions can be slow, if we want accurate blame information for errors.

Maybe link to the blog post [1] instead.

[1]: https://blog.racket-lang.org/2019/05/racket-v7-3.html

For reasons I find difficult to understand, the text is between <pre> tags and uses a monospace font (Inconsolata). It is curious that a project that cites Matthew Butterick as a contributor should make such poor decisions about typography, especially when the rest of the documentation is above average in that area.