
New Racket Language Website - kamaal
https://racket-lang.org/
======
sillysaurusx
I'm relieved they didn't change the documentation. Hard to improve on
perfection. [https://docs.racket-lang.org/pkg/index.html](https://docs.racket-
lang.org/pkg/index.html)

Also, I chuckled a bit at the "Jet Fueled" tagline. Racket's green threads
operate with a "fuel" which gets consumed over time, at which point it yields
to another thread. I think the metaphor was a happy accident rather than an
intentional nerdy reference, but still.

~~~
nahuel0x
The engine/fuel terminology is not new, it comes from the 1986 paper
"Abstracting Timed Preemption with Engines" / Christopher T. Haynes, Daniel P.
Friedman:

ftp://ftp.extreme.indiana.edu/pub/techreports/TR178.pdf

~~~
sillysaurusx
I absolutely adore that this link isn't clickable, yet it works when you copy-
paste it into Chrome.

@dang, here's an updated version of valid-url which will make the link
clickable:

    
    
      (defmemo valid-url (url)
        (and (len> url 10)
             (or (begins url "http://")
                 (begins url "https://")
                 (begins url "ftp://"))
             (~find [in _ #\< #\> #\" #\'] url)))
    

I doubt it'll get merged, but you never know.

It looks like the other change necessary is in the `markdown` function. It
checks:

    
    
      (and (or (litmatch "http://" s i) 
               (litmatch "https://" s i)
    

You'd need to add:

    
    
               (litmatch "ftp://" s i)
    

If you grep the codebase for "https" then it'll reveal any other functions
that need updates, but these are the only two in arc3.1.

Of course, the cost-benefit doesn't quite add up here – it's not like ftp
links are too common. But think of the poor university FTP servers! They'll be
forever doomed to copy-paste-hell unless this is fixed. :-(

~~~
the_pwner224
Firefox removed FTP support some months ago. Ironically when I copy paste that
link it now prompts me to open it in Chromium.

~~~
garmaine
WTF? that is ridiculous. I might drop Firefox over this.

That might sound crazy (FTP is an ancient protocol), but I spend a lot of time
scouring FTP servers for old technical reports. Mozilla can't just wish FTP
away.

~~~
read_if_gay_
I mean, if you didn’t notice for a few months, is it really that big of a
deal?

~~~
garmaine
It’s not live yet on whatever release branch I’m currently running.

------
discardable_dan
Compare it to other big language websites, like Kotlin [1] or Go [2], this
page really seems to have a poor signal to noise ratio. There is a _lot_ of
information on this landing page, and a lot of it is getting in the way. For a
language, I want to know (a) features, (b) documentation / how to learn, (c)
community. This website leads with this, but does so under playful headings
("jet-fueled") that just lead to more click-through links, and then
immediately, on the _landing page_ , jumps into advanced features (easy DSLs,
IDE support, etc.). 2/3 of this landing page could be removed, and I suspect
it would be a better landing page for it.

In addition, it suffers from a poor use of vertical space (you will see the
word "Racket" in a large font with plenty of padding 4 times on the main
page), poor usage and indication of navigation (it has 4 navbars, which are
not apparently navigation but appear to be "selling points" until your mouse
moves over them, due to their being attached to headings), and poor use of
navigation (reflowing the main page nave when you click on nav items). Compare
this to Kotlin and Go's sites, which state the name, gives a snappy summary of
the language, and then links off to more information. In the case of Kotlin,
which is closer to Racket's site, it presents immediate links to extensive,
example-driven write-ups about the most-important features on subpages, uses
the remaining of the "first page" space on a "try it now" box, and then
proceeds along vertical space (free in a browser) to demonstrate the most-
important features.

Finally, a smaller complaint: this website feels like it was made in Photoshop
in the mid-00s, complete with text-image navigation bars sliced out of tables
and drop shadows. I know someone put a lot of work into making divs look like
that, but there are very good reasons why the industry has moved away from
that design.

1\. [https://kotlinlang.org/](https://kotlinlang.org/)

2\. [https://golang.org/](https://golang.org/)

~~~
yomly
I'm biased, but I clicked through to Kotlin and it didn't have any mobile
friendly media queries - whereas I like the look and feel of the racket page
on my tiny android screen.

~~~
kaycebasques
At first I was going to say "I agree… in 2020 there's no reason not to have a
mobile-friendly docs site… but in my experience with documentation sites, not
many people visit from mobile devices". However, I just checked web.dev and
developers.google.com/web and our mobile traffic is non-trivial.

~~~
nkrisc
As a hobbyist and self-taught programmer I (pre-COVID) spent a lot of time
reading documentation on my phone while commuting home from work.

I'm very pleased when documentation works well on a mobile device.

~~~
kaycebasques
What sites worked well for you? Anything in particular about how they worked
well (or how other sites have not worked well)?

~~~
nkrisc
If have to go back and find examples, but there's not really much to it at
all. A long as it's formatted nicely for reading on a small screen, that's a
success.

Most recently I suppose would be the Rust book: [https://doc.rust-
lang.org/book/](https://doc.rust-lang.org/book/)

It's a delight on mobile. I've noticed many documentation sites she'd to be
based some publishing platform that probably includes a good response mobile
design, so it's a feature you can get "for free", yet not every docs site uses
such a platform or just hasn't implemented their own responsive behavior.

I'll update if I can remember one I read recently that didn't have a great
mobile experience.

It's really a very low bar.

------
didip
It looks great! If I may offer a suggestion, it could use a "play" section
where people can start getting to know the language right away without
installing anything.

~~~
gus_massa
There are a few unofficial sites, for example PasteRack
[http://pasterack.org/](http://pasterack.org/). (A example of Fibonacci:
[http://pasterack.org/pastes/89478](http://pasterack.org/pastes/89478) )

~~~
grugagag
There is also wescheme:
[https://www.wescheme.org/openEditor](https://www.wescheme.org/openEditor)

~~~
gus_massa
It doesn't accept

    
    
       #lang racket
    

Is it possible to use the equivalent of other variants like

    
    
      #lang typed/racket

------
cek
My son was required to use Racket in his course work for Computer Engineering
at CalPoly. I had never heard of it before. I recall one of the profs was
involved. We joked that it all sounded like a racket.

He's now a rising-star (proud/biased papa here) as an SDE at Amazon. So maybe
it's a good teaching language after all.

~~~
sthatipamala
The first programming language I learned was Scheme, as taught in CS61A at UC
Berkeley. It opened my eyes to the beauty of programming.

I had classmates who blew it off as a useless course because they already knew
Java and PHP. It was their loss; they don't have the same fascination with
computer science and I can directly attribute it to not getting exposed to
Scheme/Lisp.

~~~
outworlder
It is very difficult to get excited when your first exposure to a language
consists in

"Please ignore this public static void main() {} business, all this will
become clear by the end of the course. Maybe. If we have time to cover it all.
Just copy and paste for now. Don't forget the semicolons".

Also all the configuring of the development environment. IDEs, runtimes and
the like.

Scheme runtimes tend to be both very lightweight, run anywhere, and they give
you a REPL. So you can immediately start experimenting.

Things like Javascript and Python you give you some of that experience out of
the box too (and Python gives you more libraries) - but you'll need to learn a
bunch of syntax first. And most of that syntax is arbitrary and not relevant
to the problems being solved at all. Scheme and Lisp have a strong
mathematical background so, just like math, they end up being elegant.

------
miloandmilk
I don't use Racket every day - but I use many of the things I learnt from HTDP
every single day. Great language guided by some very generous people.

------
emccue
Weird nitpick, but "No Makefiles required" is an odd selling point to me. I
haven't seen or used a Makefile in eons, and I would wager a decent chunk of
programmers never needed to.

I'm not sure how to describe the feeling this creates. Like...I can feel the
authors other experiences shine through or something to that effect.

There was a talk awhile ago by John A. De Goes where he asserted roughly that
Scala's then pitch of "combines object oriented and functional programming"
was basically gobbledygook from the standpoint of "why would I use this
language."

[https://youtu.be/v8IQ-X2HkGE](https://youtu.be/v8IQ-X2HkGE)

I feel much the same way about Racket. Cool, very advanced DSLs and mini
languages...what does that give me? What can I _do_ with that?

Most of the page is dedicated to justifying "no wait everyone, we have the
bare minimum number of libraries" or waxing poetic about the mini language
concept.

What is the reason to use this over a less "lexically powerful" lisp like
Clojure? What is the reason to use this over one of the boring old stalwarts
like Java or Python?

Can I read from a Kafka queue? Can I call into AWS? Google Cloud? How strong
_are_ the libraries, and what would I have to commit to writing myself?

I actually do not understand why I would use Racket, and this page doesn't
help.

~~~
outworlder
> I actually do not understand why I would use Racket

You don't HAVE to.

But if you are interested, maybe this would help:

[https://beautifulracket.com/appendix/why-racket-why-
lisp.htm...](https://beautifulracket.com/appendix/why-racket-why-lisp.html)

EDIT: Also, if you want a look at the dialects, check out the comic here:
[http://landoflisp.com/](http://landoflisp.com/)

Be advised that it is extremely difficult to "sell" Lisp and related languages
to someone that hasn't bought the idea yet. No-one seems to have found a
winning formula. All people see are the parentheses (although, for some
reason, they don't see the ocean of []{}(); in other languages).

The normal experience is: you get tired of hearing about all those people
preaching about Lisp(or Scheme) and decide to see for yourself. You take the
plunge. You slave away at a book or two (or tutorials) trying to grasp the
language. And then, at some point, it all just "clicks" into place and you see
the light! That's what's its all about!

But then you start trying to explain it to other people... and you have
exactly the same problem. All those features you now know about and can't live
without? They are either difficult to explain without explaining more
concepts, or they just don't see the value compared to what they are used to.
"What do you mean, code is data? Code is not data, I use JSON for that."

Which is understandable. After all, if you are writing Scheme, you can easily
see the value. You know how Java can spend years (and sometimes over a decade,
see lambda) to get a new language feature? Well, with very few exceptions, you
can do it yourself. You know 'for each'? A Scheme(or lisp) programmer could
solve that in 5 minutes with a macro. But _you_ can't, because you are not a
Lisp programmer yet.

Similarly you probably see no problem at all with having YAML with a C program
and maybe a scripting language too. Whereas a Lisp programmer would see that
as a waste and just want to use S-Expressions for everything. Sometimes
including HTML and CSS representation. And maybe more.

But there's an opportunity cost. Up to you if you want to pay for that.

What convinced me and I found it to be true: Lisp or Scheme (and I guess
Haskell) _will_ make you a better programmer even if you don't end up using
them in your day to day. It will expose you to concepts that you may not be
familiar with - or may not had the opportunity to practice.

This is, again, subjective. Up to you. All programming languages are Turing-
complete anyway.

~~~
emccue
To be clear, I'm no stranger to Lisps. I use Clojure a ton for personal stuff
and on occasion have found ways to sneak it in to production.

The difference there is that Clojure isn't responsible for giving a wide
enough ecosystem to justify investment, it just yoinks it from Java.

Racket doesn't have that ecosystem and probably never will. Macros on the
level of common lisp and clojure are already found in those places. Racket
gives, and seems to base it's pitch around, a far more flexible hammer than
classic lisp macros.

But it doesn't do anything to offset the downsides of a small community or
justify why that more powerful "actual mini language" level DSL is something
to care about.

I am well aware of how macros can let you add your own language features and
conveniences specific to your project. Homoiconicity is an all around neat
property to have.

I'm just not buying a "beating the averages" style "you just see it as blub"
explanation either. Mini languages do have niche uses. I acknowledge that.
ANTLR wouldn't have users if they didn't. It's just not something I think is
worth writing home about.

------
submeta
Beautifully made. Like the font. And how legible it is on mobile devices. -
Learned Scheme and worked through SICP with its predecessor DrScheme twenty
years ago. - Keep up the good work.

~~~
MarkyC4
portrait tablet/landscape mobile could use some work (it's a bit squished)

[https://i.imgur.com/KLSZ33H.png](https://i.imgur.com/KLSZ33H.png)
[https://i.imgur.com/b9HXnfj.png](https://i.imgur.com/b9HXnfj.png)

------
dependenttypes
I think that it is quite nice, much better than most most modern sites (it
does not seem to require js for example and it loads quickly) and I prefer it
to the older one. My only is that it makes poor use of horizontal space - my
screen is bigger horizontally than vertically, so much space goes wasted. In
addition I would suggest offering more examples of sublanguages, such as of
#lang racket/gui which the last site included.

Anyway, good work!

~~~
dependenttypes
Apparently I either missed it or they added it afterwards. It contains a
really nice example of #lang racket/gui next to the logo.

------
chromatin
Would Racket be an appropriate first language for a thoughtful 11 year old who
has the gift of abstract thought (relatively; we are not talking Haskell here)
?

~~~
rscho
I'm just a passionate hobbyist, but I'd say yes. The integrated environment
makes it very easy to get started, the package manager makes using libs
trivial and there are DSLs for basically all programming paradigms under the
sun.

In my opinion, nothing beats it. You even have pictures in the REPL.

------
jiangplus
I think that the website of the io language is one of the most expressive
ones.

[https://iolanguage.org/](https://iolanguage.org/)

------
jakearmitage
The #lang thing is super interesting. What happens with conflicts, though? Can
I use multiple #lang? What if they have functions with the same names?

~~~
PuercoPop
You can use multiple #langs, in separate files. The name collision is
unrelated to the #lang of the file. It is handled by the module system.

------
lukeplato
Always been curious, how do people decide between racket vs. scheme vs. common
lisp anyway?

~~~
neilv
First, Racket was originally called PLT Scheme, but then added a lot of stuff,
and then broke some standards compatibility. (I'm currently interested in
moving back to more-portable Scheme, possibly using Racket as my default
Scheme implementation.)

There are huge differences between Scheme and CL, and you can usually tell
when, say, a person good with CL is writing Scheme code.

(Disclaimer: I've used both languages professionally, and am a Scheme expert,
but am a CL novice, other than my experience using various Lisps.)

One of the differences is size: You can sit down in half an hour and skim
through the R5RS paper (skipping the scary sections on formal semantics and on
first-class continuations), and be ready to sit in front of Scheme and start
programming, even if you initially won't be writing idiomatic Scheme. Though
you do need to add a lot more library to Scheme to do real-world things, the
core language is small and elegant.

There's also noticeably different idiomatic programming. An idiomatic Scheme
programmer might do things like avoid mutations, leverage tail call
optimization, use only hygienic macros (syntax extension) and maybe fancy
tools for that (e.g., `syntax-parse`), not use dynamic capabilities of the
language so much, never go and optimize by looking at native code generation
(though Racket now has tools for looking at bytecode/IR), and use simpler
language features for many things (not know and leverage the CLOS MOP, nor
make complicated `LOOP` uses).

If I was doing a startup with a Lisp for my launch, I'd personally use a
Scheme (maybe Racket), because I happen to already know all the big&small
things I need to DIY and manage, to make it viable for things like Web
startups. For CL, those things would be different, but I think also doable and
more proven already.

I do think I could get a team up to speed on Scheme faster than CL, because I
can say "This week, use the core language, plus these packages, and then next
week there's some non-obvious idiomatic stuff that I'd like to propose we
learn, but I have to explain it, because it's not in any book I know of."

------
benatkin
If it has a photo where people aren't wearing masks and/or social distancing,
it doesn't feel new to me.

~~~
superdisk
I went to look at the picture and noticed I'm actually in it! Cool. The pic
was taken at RacketCon 2018.

------
valbaca
Looking good!

potential off-topic but this make me think of this:

Can one work through SICP using Racket?

~~~
vvillena
There's a #lang sicp in Racket that emulates the Scheme of the SICP book, with
all the functions you need.

~~~
neilv
[https://docs.racket-lang.org/sicp-manual/](https://docs.racket-lang.org/sicp-
manual/)

------
hitekker
A compressed header that looks good on mobile? Wow.

The rest of the design looks well crafted too.

------
nyanpasu64
Ironic how Racket's new homepage includes a multilingual print example,
whereas Rust's redesign removed it.

------
saagarjha
Perhaps they could come up with something different for the first header?
Because saying "Racket, the Language-Oriented Programming Language" right
after "Racket, the Programming Language" seems a little too similar.

~~~
grok22
That seems intentional -- the 2nd header is to highlight that it has features
that help in creating your own language variant (and is a big-part of it's
many strengths).

~~~
saagarjha
Yeah, I think it is–however, it's still strange to have those two and then the
third "Racket, the Ecosystem" that doesn't seem to fit the pattern.

~~~
grok22
The are section titles and features regarding that section are listed right
below it. It's a bit repetitive, but still trying to highlight the things that
make Racket a great language.

------
Naac
I believe this is the source code for the Racket lang website:
[https://github.com/racket/racket-lang-org](https://github.com/racket/racket-
lang-org)

------
Buttons840
Is there still a blog / news section? I don't see a link to those?

~~~
pryelluw
Its in the footer: [https://blog.racket-lang.org/](https://blog.racket-
lang.org/)

------
agumonkey
nice spin on the proglang homepage, 'KISS

------
codazoda
I didn't sign in too far, but isn't the first line of code on their landing
page a typo?

(define my-language 'English)

Looks like it's missing a closing single quote. I suppose it could be
optional.

~~~
vvillena
Strings in Lisp are surrounded with double quotes. In this case, 'English is
not a string, but a symbol. Symbols are arbitrary flags with readable names.

There are lots of languages with symbols. Some of them even use the same
syntax, like Scala (symbol usage in Scala is uncommon, though). However, the
most prominent non-Lisp language that uses symbols all the time is probably
Ruby.

~~~
kazinator
Well, rather, _english_ is not a string, but a symbol.

Because symbols denote variable names in Lisp code, the expression _english_
calls for the value of _english_.

If we want the value of the expression to be the _english_ symbol object
itself, we need _(quote english)_.

Because that is too verbose for a language in which symbolic processing is
prime time, there is a shorthand prefix notation for it, _' english_.

------
cpill
Oh boy, what the world needs now: another Clojure. How is it going to compete
with the raging success of that :D

~~~
vga805
If you have nothing productive to say, don't comment. It really is that
simple.

And Racket is almost a decade older than Clojure.

