
Creating Languages in Racket (2012) - headalgorithm
https://cacm.acm.org/magazines/2012/1/144809-creating-languages-in-racket/fulltext
======
darkpuma
If this subject interests you, I strongly recommend this book:
[https://beautifulracket.com/introduction.html](https://beautifulracket.com/introduction.html)

------
fovc
Is Racket mostly for teaching and academia, or is it also used in production?
If so, are there any particular areas it is strong in?

Typed Racket seems like a more cohesive language than Typescript while
retaining the dynamic typing escape hatch, so I've been eyeing it for a while.

~~~
mruts
Racket is an excellent language for DSL’s, compilers, and interpreters. I’m
not aware of any other language that has as sophisticated and powerful tooling
as Racket in this regard.

It’s also really good for creating GUI’s.

As I wrote in a previous HN thread about Racket, I think Racket’s strong suit
is developing internal company tooling that is run locally on an individual
machine. Great as tooling for analysts, data scientists, etc.

I wouldn’t recommend Racket for a server unless it was serving relatively few
requests. The JVM would probably be a better choice.

From just a quality stand point (documentation, libraries, design) Racket is
undoubtedly the best and most advanced lisp on the market. From a practical
standpoint, clojure might be better in many cases.

Edit: PS: Typed Racket is really quite nice, though I found it to be too
restrictive to use all the time. In a language like Haskell you don’t really
feel constrained by the type system since the language is designed around it.
In Racket this isn’t the case so you quickly discover that the subset of
correct programs with static typing is much much smaller than the subset of
correct programs with dynamic typing.

Fortunately as you mentioned you can use gradual typing and everything works
fine. My workflow when I used to use Racket for work was to write a module,
putting the types as comments. Afterwards, I would attempt to make those types
real, skipping over any functions in which it was too onerous.

Also, Racket has runtime contracts that can provide similiar (or more
powerful) guarantees as static typing. Though you have to turn them off for
production because they absolutely destroy performance (orders of magnitudes
slower).

------
nickmain
Previously:
[https://news.ycombinator.com/item?id=3225718](https://news.ycombinator.com/item?id=3225718)

~~~
weberc2
I take it the "(2012)" in the title is wrong since your post is from 2011?

~~~
Jtsummers
The publication date is January 2012. It was likely released in December.

------
equalunique
Might be my unreliable mobile browser, but this page isn't loading.

~~~
pasbesoin
It's there.

Here's a copy that's in the Wayback Machine (aka archive.org).

[https://web.archive.org/web/20190113223131/https://cacm.acm....](https://web.archive.org/web/20190113223131/https://cacm.acm.org/magazines/2012/1/144809-creating-
languages-in-racket/fulltext)

