Hacker News new | past | comments | ask | show | jobs | submit login
Racket v8.0 (racket-lang.org)
276 points by azhenley 7 months ago | hide | past | favorite | 41 comments

This announcement assumes everyone knows what Racket CS is. I think they should explain CS == ChezScheme and link to https://docs.racket-lang.org/guide/performance.html#%28tech....

Thanks, exactly my first thought was it stands for Computer Science

I'm simply amazed by Racket. It stands out because while it is developed by academics and based on a language with a history of caring more about the language than solving real problems it comes with excellent documentation, good performance and decent libraries including unsexy things like a GUI toolkit.

I agree with you about the positive points of Racket.

I would note however, that being developed by academic greats and being based on that language is exactly what enables it to stand out. It is usually academics, who innovate in PLT and come up with new elegant concepts, that one can use to tackle lots of challenges.

Congratulations! It's been a long time waiting!

I've wanted to develop desktop UIs that look professional and are lightweight, and I wonder if Racket, with its built-in UI framework, could be a good choice.

I did try it once but the hello world app was already really heavy (200MB of RAM instantly taken , if I remember correctly), but maybe I did something wrong (debug mode perhaps??)

Can I package a Racket app with a MacOS installer and sign it? How about Windows and Linux?

I was/am in the same boat. A few months back someone recommended this blog to me: https://alex-hhh.github.io/

If you want to see some "real world" high quality Racket GUI stuff this is the place to go. Very inspiring. I'd love to do more with Racket & its GUI lib.

WOW - in his space invaders example, his animated sprites are displayed in the REPL. So neat.

I've been using Racket on the rpi3 (BC not chez as it's not in the repos yet) and the resource issue is exacerbated (as well as the start up times). I asked about reducing the start up time and resources load recently on the subreddit, but other than doing things like this below I've found nothing.

  #lang racket/base

  (require racket/draw pict racket/gui/base racket/class)

  ;; avoiding pulling in to many extra deps so have to redefine some useful functions
  (define (first lst)
    (car lst))

  (define (second lst)
    (cadr lst))

  (define (third lst)
    (caddr lst))

  (define (false? val)
    (not val))

If anyone cares the code is here https://gitlab.com/diegocrespo/imgmac/-/tree/master. For context this is a paint program that currently creates a 1024x748 window with a canvas, 31 buttons, and a file menu. It uses 280M of memory on my desktop running Manjaro, which isn't the greatest. In my testing, typed racket also increases the memory uses.

Thankfully after creating a basic frame and canvas, the jumps haven't been as big, but I could easily see the program going to 400M by the time it's done. I will download Racket 8.0 today and see how it performs

I think once Gerbil scheme becomes more mature I'll do more work in that. It's faster, smaller, and borrows a lot of things from Racket that I like.

*EDIT* I installed racket 8.0 (super easy and removed the old installation as well!) and compiled my program. Compiling it and running it results in it going from 280M down to 220M, That's a 27% improvement. Creating an exe brings the memory usage back to 243M but that's still down. I'm less familiar with creating exes so there might be some settings I can tweak.

Generally speaking, for smaller size you should use #lang racket/base and then only import the extras you need.

I don't know the current memory consumption, but FWIW Racket recently improved on that front.

As for debug mode, you should AOT compile with 'raco make' to run a fair test.

Awesome. Racket is the best. The phrase “language oriented programming “ was a turning point for me when I first encountered it.

Can you ELI5 it's value proposition?

*Disclaimer I know nothing about German and very little about English Grammar*

In German there is a word called "Schadenfreude" whose literal translation into English is Schaden "damage" freude "joy". The actual meaning is roughly ...

  The experience of pleasure or joy, that comes from witnessing failures, or humiliation of another. 
Because of the "design" of the English language, it is difficult (but not impossible) to relate these complex emotions in the way it is done in German. Because of this we have to say "I am experiencing joy from seeing X person in pain" while the Germans get to say "I feel Schadenfreude". The German way is more succinct. Coincidentally in programming, there are problems which if you are just constrained to the syntax and semantics of your programming language, get solved by saying "I am experiencing joy from seeing X person in pain" instead of "Schadenfreude". By being able to create a new language with less friction than it has been in other programming langauges before, whose design allows you to solve your problem with the word "Schadenfreude" instead of "I am experiencing joy from seeing X person in pain", allows you to create programs that are more expressive, succinct, have less bugs, and be easier to maintain.

I'm imagining Marketing panicking when they hear us in Engineering:

Q: Can you explain the value proposition of DSLs?

A: Sadism.

You say that, but my (albeit weakly held, so CMV) theory is that any software engineering is just a form of creating a DSL, it just isn't generally explicit.

Given more expressive power, with appropriate training, it could be incredibly empowering, allowing for more expressive and maintainable systems.

It could also create an absolute mess, and some might argue that more power means more ways to shoot yourself in the foot, hence I think that kind of methodology requires the training up front and overall good software discipline.

I am a junior-mid developer so I know squat really.

>Q: Can you explain the value proposition of DSLs?

A: Cognitive Impedance Matching

Well, Schadenfreude is a loanword in English, albeit not common.

> Because of this we have to say "I am experiencing joy from seeing X person in pain" while the Germans get to say "I feel Schadenfreude". The German way is more succinct.

To be fair, in English we would just say schadenfreude today.

edit: I'm apparently blind and missed the same comment already made yesterday: https://news.ycombinator.com/item?id=26134050

Guess I'm a day late and a buck short.

In substance: easily make a DSL targeted specifically at your problem.

This proposition is often criticized by software engineers for resulting in code that is potentially inscrutable to anyone but the writer. IMO, this misses the forest for the tree. Sure, one-off DSLs probably aren't suited to entreprise codebases you'd use Java for. But what the critics miss is that this truly enables domain experts. In that way, it's a bit like the MS Excel value proposition cast into a (very well-designed) programming language. Which makes it ideal for solo devs, scientists, small teams, etc. (as most lisps). That's what makes Racket interesting to me, at least.

My job is to doing due diligence on tech companies during major investments and acquisitions, and one of the most successful (and interesting) I've seen was doing exactly what you describe. It wasn't Racket, but the code base was an engine with a very sophisticated DSL enabling all their in-house domain experts to work hyper-productively. Their work was split into an engine, which their low level super-senior hackers worked on, and the assets, which were the things customers bought and were made in a DSL by highly educated domain experts. It was really impressive, and they are doing very well. I've long been convinced that this is the logical highest level of "onion/hexagonal/ports and adapters" architecture, and seeing what they had done was really cool.

General purposes programming languages that enable to easily and expressivelly build readable DSLs are useful. But what does Racket bring over say Kotlin DSLs? https://kotlinlang.org/docs/type-safe-builders.html

For building DSLs the following features are useful: Infix/postfix functions, Operator overloading, Varargs/spread operator, Scope controling what is allowed. Other features??

I'm not a Kotlin expert, but I expect that it enables easily interpreted DSLs. Racket enables easy compiled DSLs through its macro system. So, no interpretative overhead.

Also you can really, really change both syntax and semantics: https://docs.racket-lang.org/2d/

Although not similar technically speaking, Graal/Truffle is a better comparison in spirit, IMO. But Graal/Truffle is hugely complex, with many many man-hours in it.

Classic example and discussion: https://www.reddit.com/r/programming/comments/i1slm/comment/... https://www.hashcollision.org/brainfudge/index.html

I think the DSL logic is at compile time, the Kotlin annotation generate source code at compile time just like a macro and enable compile time type safety. Also the performance is expected to be order of magnitude better given the JVM.

Also you can really, really change both syntax and semantics: https://docs.racket-lang.org/2d/ Exactly, racket give you much more freedom because of this, I don't know the use cases but it's indeed more powerful. A comparison with Truffle would be great! I wonder if a higher level/simpler but less powerful abstraction on top of Truffle could bridge the difficulty gap.

Let's say you and your friends wanted to figure out the best way to share toys so that everyone is happy.

There's a new method to doing that, pioneered by these Racket folks, called "Language Oriented Programming".

And what it means is that the first step to solve your problem is to create the simplest language you can think of to describe your problem.

So let's create a language where you can list everyone's toys like this "ballToy", "elsaToy", "blockToy". And then we can list all your friends like this "Adam", "Emily", "Maya". And then we can list feelings like "Happy", "Sad"...(going to skip the meat for brevity)...and then we rearrange these words until we get the program with the most Happys! And we've solved the problem using "Language Oriented Programming". We spent our time not on the computer language, but on creating a new simple domain specific language customized for our problem.

Does anyone have any summaries or news about the ongoing Racket team effort to develop modern syntax?

It is called rhombus and there is an open discussion going on at https://github.com/racket/rhombus-brainstorming

Matthew Flatt has said that now that Racket on Chez is done, there will be more time to devote to this problem. I'm excited to see where the conversation goes in the next coming months.

Still in the brain storm phase.

Hello everyone, I am really interested in the "language-oriented" approach from Racket. But as a person with limited skills in computer programming (mostly scientific computation, read not a software-dev), I haven't been able to find a decent walk-through of how one would go about building a DSL.

I have many use-cases in mind for a DSL ( research projects and hobby). So would you know of some full-fledged (open-source) use cases where racket has been used to create DSLs ?

For anyone trying to install on Windows and getting a big scary warning of doom, it's probably nothing to worry about [1].

[1]: https://groups.google.com/g/racket-dev/c/Oxi3dJn-EME

I tried the new release of Racket v8.0 (Chez backend) built for Apple M1 Silicon this morning. I have a version of my Common Lisp Knowledge Graph Navigator written in Racket. Very fast both on boot up (for the IDE) and running my program. Thanks to the Racket (Scheme) team!

Anyone using Racket in production?



Besides of course all the Racket pages/systems (home page, package system, continuous integration system etc).

E-commerce is also possible.

https://defn.io/2019/08/20/racket-ecommerce/ "matchacha.ro, a small e-commerce site selling Japanese green tea"

If you are into quilting, then https://www.youpatch.com/ uses Racket.

All of Hacker News is written in the Arc language, which runs on top of Racket.

I don't know if it counts as “production”, but I quite often use it to develop small GUI utilities in academic settings.

Performances are bad, but when playing with relatively small datasets, the portable (Linux/macOS/Windows) GUI, the huge stdlib, the ease of deployment of fat binaries and the pleasantness of the language in itself make for a very seductive tool.

~20 years ago, we developed the commercial software using the MzScheme - it was quite successful project in ex-USSR, I'm not involved into development since 2007, but Scheme was used until at least 2012-2013th, maybe it's still used.

I'm currently working on a TSQL parser in Racket because I want to do some code analysis on a few huge stored proc files (some of which are over 30k lines of code). I didn't want to use existing parsers because the trees they produce are monstrous [1,2]. Tried doing some fancy grep work, but it was giving me way too many false matches and wasn't as sound as I would have liked.

I could use any language with reasonable parsing tools, but I like how flexible Racket is about it. Currently using megaparsack[3], but there are many different parsing tools available depending on your needs. Also, once you have done parsing, there are lots of convenient ways to manipulate the parse trees into whatever shape you need.

I also think Racket has a lot of tooling that would make it great for large code bases.

-It has great offline docs (scribble) which don't force you to use some comment based system like JavaDoc.

-It has a very powerful and fast contract system that can be attached either at definition time like most languages or only at module boundaries.

- While it has a macro system, it has a really good macro debugger (it lets you view how the code is iteratively expanded with options to show/hide the expansion of various macros). Since even non-hygienic macros deal with syntax objects and not just datums, macros don't even screw up error messages since line/column info is preserved!

- You compile to executables unlike most scripting languages.

- You can write some code with types and some with them, but unlike say TypeScript the boundary between typed and untyped code is sound since contracts are used to verify these boundaries.

- A lot of the time you don't even need types because most names (i.e. variables and functions) are verified at compile time (to be more specific, at macro expansion time).

- It has very aggressive sandboxing tools that let you control not only what names are visible to some untrusted code, but also control how much memory it uses without creating a new process.

- Safer global variables in the form of parameterize. Very convenient for stuff like when you need to temporarily change the stdout for a single call.

[1]: https://github.com/datacamp/antlr-tsql/blob/master/antlr_tsq... [2]: https://docs.microsoft.com/en-us/dotnet/api/microsoft.sqlser... [3]: https://github.com/lexi-lambda/megaparsack

Interesting coincidence - I'm working on a parser that parses the AST produced by JSqlParser[0] for a create view statement to generate mapping between the columns of a view and the columns of its underlying table. It is an interesting example of having to use the visitor pattern[1].

[0]: https://github.com/JSQLParser/JSqlParser [1]: https://en.wikipedia.org/wiki/Visitor_pattern

Another question, how racket compares to clojure for production developmen?

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact