RacketCon 2022 | Hacker News Reader

RacketCon 2022

con.racket-lang.org

66 pointsjessealama25 comments

Even if you don't care about Racket, the talks at RacketCon are always really interesting and it is a very affordable conference.

October 28–30 at Brown University, Providence, RI, USA.

Funny to see anything Racket related rocket up to the front page of HN. My alma mater (Northeastern) is heavily involved in its development and the infamous intro CS class (Fundamentals of Computer Science 1 / Fundies 1) is taught in it. I only appreciated its beauty after I learned how to code deeper into the program. Horrible experience for anyone coming into it with no CS background.

What makes it horrible? I never took a course in Racket or any other language. But the documentation and HTDP look very beginner-friendly.

I just think functional based program is a bit harder to reason about for newbies. Programming did not click for me until the third class in the track where we learned object oriented design. Pretty common experience in the program as well, scared away a lot of people who took fundies 1 to explore the major or to minor in CS.

I took the class as a freshman, taught by Matthias, and then was a grader/lab helper the following year. (Oh gosh, this is all 15 years ago now)

In my observation, it was those with previous java/c++ experience that couldn't let that go who struggled the most. Total newbies were a blank slate and more likely to 'get it', assuming they have the abilities needed to succeed in a CS program.

I would say that was my experience as well. It actually took me a while to understand why I would use classes and objects.

Could just be different strokes for different folks. I thought OOD in java taught by Lerner was way better (Card game project opener was wonderful) and just made more intuitive sense. I didn't honestly get functional programming until circling back to Racket in PL.

I would also say Matthias is a legend and my instructors were nowhere near that level.

+1 as someone who took and TAed it for multiple years at UBC. The people who came in with preconceived ideas of CS were the ones that struggled the most.

We had a bypass exam, which was more or less the final for the course. If you passed it, you got the credit. I don’t think a single person passed it while I was there.

Matthias Felleisen co-wrote a book on Java, elegant uses of class-based inheritance, and elegant design patterns.

https://mitpress.mit.edu/9780262561150/a-little-java-a-few-p...

Really? I'm a self taught programmer, and one the best MOOC courses I took was How to Code taught by Gregor Kiczales.[^1] I believe it's based on HtDP. I thought it was great experience. Although, I did no know a little Python coming in.

[1]: https://www.edx.org/course/how-to-code-simple-data

I was one of the first people to take that course when it first launched in person at UBC! There were a dozen people in that first year pilot program.

It gets so much hate for not being a “traditional” Intro to CS course. And yet, learning about recursion so quickly and getting such a strong foundation with it is invaluable for figuring out new ways to solve problems. It’s one of the only courses that I personally think taught me something so fundamental that I still use all the time.

Gregor is also a gem of a human. I’m incredibly grateful I’ve been able to get to know and learn from him while at UBC.

I took Fundies 1 at NEU last year, but I came in with a good amount of programming experience. I appreciated it because it forced me to think in a new programming paradigm (functional) but for a lot of my classmates who were beginners it was tough because of the much more puzzle-like nature of the problems. I also didn't think it was very fair to these students for the curriculum to immediately abandon Racket after the first semester and go right into Java for the second. The Fundies classes can at times be very discouraging because of the intensity.

What’s special about Racket? What makes it stand out compared to Lisp/SBCL/Scheme?

I recall a while back John Carmack tweeted about writing some project in Racket & it’s been vaguely on my radar lately.

Lisps let you define macros. Racket lets you define languages.

https://docs.racket-lang.org/guide/languages.html

https://docs.racket-lang.org/guide/more-hash-lang.html

Example of a language-in-racket: https://github.com/soegaard/minipascal/tree/master

this is so cool! Pascal code without the parentheses.

The worst possible programming scenario is usually being locked in to an internal hacked together proprietary language. I don't think trying to make a new language for every program is a good idea and is almost the polar opposite of what I would consider good programming.

It lets you create languages like Pie which is designed to teach others about dependent types:

https://thelittletyper.com/

That seems like an extreme niche use that isn't suited for general purpose programming.

Racket's main use case is pedagogy and PL research.

Not to mention arc/anarki (hn is/was written in arc - anarki comes with a "news" example app/forum):

https://github.com/arclanguage/anarki/tree/HEAD#readme

Until a few years ago Racket was a dialect of Scheme. In addition to the main language "Racket" it also supports R5R and R6R in the standard distribution, and also R7Rs using a user maintained package.

There are like 20 of additional languages as part of the distribution. Some are variants, like "Typed Racket" that is like racket with static types. Other languages that are more/completely different and/or almost unused and keep for compatibility or as a demo of some strange feature. And also there are many user defined languages that can be downloaded as packages.

The batteries are included. I had to make a program that uses IMAP, SMTP and web scrapping. In another I used support for gzip and xml. In both cases, and all of that was installed by default. And also there are many user defined libraries that can be downloaded as packages.

Racket is more immutable than a normal Scheme. For example, lists ("cons") are immutable, and that allows the generation of faster code. Anyway, you can load a library to create mutable lists/cons if you need them.

There is more separation of the normal code from the code in macros. So normal code does not affect the code inside macros. Some people like that, and some people dislike that. It's better to reason about macro expansions, but to share a function between normal code and a macro you must define it in another file.

It's quite fast in the Scheme family https://ecraven.github.io/r7rs-benchmarks/ Still like 5x slower than C, but 5x faster than vanilla Python. https://benchmarksgame-team.pages.debian.net/benchmarksgame/... YMMV

Thanks for such a detailed response! At a glance it seems pretty interesting, and the performance is quite good too. I’ll have to toy with it for my next project.

1. Discord and discourse forum make it easy to get answers and search for solutions

2. Language is evolving in both a low level (Racket on Chez) and high level way (zuo make replacement)

3. Package manager built into the language

4 Gradually typed sister language

5. Compiled

6. Binaries for multiple Oses for easy download

7. Built in GUI library

8. Drracket for an all in one text editor and language solution.

Some schemes/lisps have some of these, but they are either bolted on after the fact, or not widely adopted in that community.

I love Racket. It was the first language I learned at the University of Utah, and is easily my favorite dialect in the Lisp family. But I'm hesitant to use it for anything beyond toy projects, mostly because the future of Racket seems to be directly dependent on getting academic research money, and publishing papers.

Reply on news.ycombinator.com