Creating Languages in Racket (2011) | Hacker News Reader

Creating Languages in Racket (2011)

queue.acm.org

127 pointsb-man44 comments

I really wish the Racket team would write a book on Racket’s language making capabilities, or create a MOOC. I attended Racket School 2019, and it was awesome. The material was well put together and walked us through macros to #langs. But the only published material to walk a person through macros and building languages are Fear of Macros and Beautiful Racket.

I have many ideas for little DSLs in Racket, but I am too slow and am slogging my way through learning how to create them.

I feel exactly the same way. Racket considers this one of it’s killer features so they should be plastering it all across the Internet.

Hi,

What type of material would you like to see?

What parts of the API are you finding difficult?

Agreed that a book would be great, but worth mentioning that the course page for racketschool 2019 itself now provides the current best intro to syntax/parse and DSL making in racket: https://school.racket-lang.org/2019/plan/

That’s a good resource for sure, so thanks for pointing people there. Basically, it would be great to take that year’s Racket School and turn it into an expanded and more streamlined work.

There's this https://youtu.be/WQGh_NemRy4

Pretty basic, but it helped me a bit.

What do you think of https://beautifulracket.com/ ? Isn't it exactly what you're asking for?

You seem to say, I wish there was a book on X, but there is only this book on X. What more do you want? I don't mean that rhetorically, what additional things would you like to see covered?

I've worked through Beautiful Racket before, though it's been awhile. I think my main issues are

1. You need to install the Beautiful Racket package, which makes the starting point for creating the languages easier, but is not representative of how it's used in the Racket Docs (not that I'm saying the Racket docs have a better intro)

2. Uses Brain Fuck. It feels like there has to be a language that fits in between unintelligible but easy to parse, and extremely verbose and complex. (It's probably scheme but that's taken in this context)

And sometimes I just need to see the same problem from a few different angles before it will stick. That's why Greg's Fear of Macros wasn't able to take me all the way to a comfortable place with macros.

I think BR is a great book, and I definitely learned a lot from it, I'll probably go back to it at some point to see if I can get it to click. I've been on a Racket kick recently so I've got a decent amount of hours into the language.

Also I'm always struck with a feeling when I'm coding in Racket where I go "Would a dsl be good here?" I know Racket makes it easy but I don't even know about what makes a good dsl, or how certain dsls might be harder than other based on the way Racket does L.O.P. Again this might just be from inexperience.

Lastly I would also like to see some examples of typed languages being created using typed Racket. I know there is the Turnstile library, but from my understanding it makes it easier to created typed languages, but that the possibility was there before. I'd rather learn the hard unabstracted way first before moving to using a library.

Beautiful Racket is a really nice book.

I wish there was a long tutorial on DSLs + static analysis, preferably abstract interpretation.

Develop a DSL that is a bit beyond a toy example, and show how to carry out static analysis. All in one place.

I think this would help a lot towards making the goal of Racket, language-oriented design, more popular.

There’s not a book on x in this case, which is why I said what I said.

A language is more than just a reader and expander for toy languages. It also includes domain specific editor functionality and domain specific errors, among other things (like understanding macros and phases at a deeper level).

It is certainly true that Racket has a ridiculously low number of books on it that aren't textbooks. It's a real pity. I like Racket a lot, but there is so little focus on use outside of academia that I don't hold my breath on it becoming a production appropriate tool for typical business software.

It’s growing;

Racket Programming the Fun Way An introduction to the Racket functional programming language and DrRacket development environment to explore topics in mathematics (mostly recreational) and computer science.

https://nostarch.com/racket-programming-fun-way

More books at https://racket-lang.org/books.html

If you feel like sharing the ideas, I’m sure many people would be interested in seeing potential example applications where this (abstract and somewhat uncommon, in other languages) capability can be put to good use.

You can go as complex as your own type system. One type system was added to Racket called Typed Racket. No new features were needed in the language or tooling, they just used Racket macros to build a Racket with static compiler errors which integrates with the IDE.

Two similar cases. One is Typescript. That's a new language with different syntax, a new compiler which targets JS. It also provides its own tooling for IDEs. Another is Python. Over time there were PEPs to add syntax for type hints, and now type systems are being added to the language.

When Racket did this, they were able to do it in Racket without adding more features to the compiler or IDE. There's built in support for static analysis, compiler errors, editor integration. Not to mention a way to organize all the information you need to do type checking in the compile steps, and make that information accessible in the right places. The new type safe Racket was built using plain ol Racket.

There's a reasonably accessible paper about this here: https://www2.ccs.neu.edu/racket/pubs/scheme2007-ctf.pdf

So here are some of my ideas:

1. Play around with static analysis checks. I want to rebuild Typescript style structural inference to Racket. I like how TS is unsound (has no runtime performance penalty for mixing untyped code), and is easily disabled via any if it's in the way. I love the focus on great error messages. Maybe one day I will contribute to Typed Racket :)

Making your own compiler error appear in Racket is just 5 lines of code. https://gist.github.com/srcreigh/a0a087adc26e15af0160e8866d4...

2. New syntax for creating structs. Racket had structs that are initialized like (point 1 2). What if you want keyword syntax ie (point #:x 1 #:y 2)? What if you want that to work with match too? Do you want a JS-style syntax such as (point #:x #:y 2) which pulls in x as an identifier? You can do all this! The rebellion library is pretty awesome in this regard [1], with some sample usage of it in a script here [2].

[1]: https://docs.racket-lang.org/rebellion/Data_Types.html [2]: https://github.com/srcreigh/shift-remapper/blob/main/generat...

> I like how TS is unsound (has no runtime performance penalty for mixing untyped code), and is easily disabled via any if it's in the way.

This is already done. See https://github.com/racket/typed-racket/pull/952 for RFC and https://github.com/racket/typed-racket/pull/948 for the implementation.

Excellent. Can't wait to try it out.

It's exciting to think of "Deep" checking as a complement to optional checking. Use a mix of both in one code base to play their strengths. For example it'd be great to define a deep type checked module for parsing data. You get static errors and runtime validation too. But, also, use that module from an optionally type checked module, which doesn't add any extra runtime costs if some of your other code / dependencies are untyped.

What about "Semantics Engineering with PLT Redex"?

People interested in language design and learning Racket in one book might enjoy this book https://beautifulracket.com/

Edit: Also Programming Languages: Application and Interpretation, which I haven't been through yet, so can't endorse fully: https://cs.brown.edu/~sk/Publications/Books/ProgLangs/2007-0...

More books: https://racket-lang.org/books.html

Is it common to use the Racket IDE or is Emacs equally suitable? So anyone using Emacs to program in Racket Scheme?

Emacs is fine; Racket mode is very good [1]; but DrRacket is worth a spin if you're unfamiliar with the language/ideas.

[1] https://www.racket-mode.com/

Racket's IDE is pretty good, but it doesn't match the pure editing facilities of Emacs, and racket-mode supplies similar functionality. I use exclusively Emacs for Racket, and other Scheme-like languages.

I find Emacs with racket-mode much better for editing, but DrRacket has some really nifty IDE features that racket-mode doesn’t have. I probably split 80/20 between them

DrRacket is a pretty good IDE but, it doesn't have the flexibility and consistency of Emacs. A lot learning material for Racket features the DrRacket IDE.

I find it easier to trace errors in DrRacket than racket-mode, but use Emacs for 95% of my Racket coding

As the other commenters have mentioned, Racket Mode is excellent, especially racket-xp-mode: “An optional minor mode that enhances racket-mode to explain and explore code.” https://www.racket-mode.com/#racket_002dxp_002dmode

The other thing worth mentioning is Racketeers often use their favourite editor, only switching to DrRacket or Racket Mode when they need specific functionality.

Are there any vim users that use Racket? If so, I'd be grateful if you could let me know your workflow.

Everything seems to be emacs/DrRacket focussed from what I see.

I've used this, for neovim, and it's very good! https://conjure.fun/

Works with Clojure, Racket, Fennel and Janet.

This is new to me and it looks awesome! Thanks for bringing it to my attention.

There are quite a few vim users, to the extent that the manual addresses their needs directly: https://docs.racket-lang.org/guide/Vim.html

A common pattern for Vim users is to happily code in Vim and occasionally switch DrRacket for specific tasks. And use the command line tools - https://docs.racket-lang.org/raco/index.html

I'm currently trying to create a language but have never done it before. I'm a web developer, so I'm writing some reduced test cases in Node, but I seriously doubt that I'd use it for actual parsing.

Racket seems like a good choice; have never heard of it before. Anyone know the pros/cons/alternatives?

Check 1.3 and 1.4 at https://school.racket-lang.org/2019/plan/mon-mor-lecture.htm... to get an idea.

I'm working on a language also, it's a lot of fun!

What's yours about?

I'm trying to build a language for UI designers. The goal is to give them a very easy language that allows them to describe visual behavior using grammar and concepts that are familiar to them.

Entirely declarative, low-tech, almost like pseudo-code.

I hope to hear more about your project. And fwiw, my very limited experience suggests that Racket may be a great way to start.

One potentially untapped potential of Racket that I think about is sort of as a universal language platform. Seeing more already existing languages reimplemented in Racket would be cool. I know the underlying implementations of other languages don't always line up to Racket, and that you wouldn't be able to use the libraries of the language in question, but it could potentially reduce the friction of extending software you love.

You want to extend this piece of software to suit your needs, but aren't a fan of Racket, extend it in a language with Javascript like, Python like, Java like syntax etc (that ultimately compiles to Racket). An example would be a Game Engine in Racket, that has bindings to other languages a la the Godot Engine, or some other piece of standalone software.

After attending Racket School in 2019, I was able to do a Racket implementation of Tabloid in a couple of days: https://github.com/otherjoel/tabloid ...fun stuff!

Would this, or something else, be a good solution for producing XML-based output, similar to an HTML templating language?

Yes, I think the `xml` library in Racket is quite nice for generating XML and XML-like content: https://docs.racket-lang.org/xml/

Reply on news.ycombinator.com