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.
The engine/fuel terminology is not new, it comes from the 1986 paper "Abstracting Timed Preemption with Engines" / Christopher T. Haynes, Daniel P. Friedman:
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. :-(
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.
Ditto. Works as is on Firefox 80. No need to edit the URL. It is however not clickable, but you can select it and click "open in new tab" and it opens the PDF just fine.
The docs would benefit from some mobile support, it's a pity that documentation sites usually don't have mobile support as if people only use documentation sites when they're coding. In fact, there are a hell lot of reasons to view them while on mobile... and yet so many documentation sites don't have responsive designs. :-(
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.
In earlier discussion of a draft, a year ago, I looked at a bunch of examples, and zeroed in on Nim's home page (at the time) as a possible good example/inspiration for Racket (especially since I was pushing on a "3 ideas" focus, which, IIRC, Nim was also doing):
* Collectively, people think a lot of stuff is important, and don't want to drop it from the home page. A vicious designer would step in and cull and massage heavily, ignoring the screams of pain from most people. (Only in the end, might people generally agree it was worth the suffering, and then they'd help beat down anyone who tried to sneak bloat back in, after the carnage that everyone went through to get there.)
* The people in charge and doing the work on the site, as a group, don't have the same ideas of what's important that professional practitioners do, nor the state of competition. So, priorities, phrasings, assertions, etc. will sometimes seem odd. This has come up at least a few times, in various ways, and might be part of why Racket didn't go mainstream when it had a better chance. (Though the leadership is not just pure academics. Just to pick the most prominent example, Prof. Matthew Flatt, besides the research and domain background, is a very solid programmer, with some good sense of software engineering.)
* As a subset of general visual design, good graphic designers seem to do many subtle things that us techies don't fully appreciate. Familiar analogy: a novice software developer not only isn't yet able to do great work on tricky problems, but they don't even yet know what great work is, nor are they able to say what's great and not about some example they see. (The creators of the new site are mainly programming language and CS education people, not visual design, not HCI, etc., except sometimes people like [1].)
On the upside, if a site for some techie thing looks a bit homely or awkward in some ways, you know it's at least not a tech offering driven by marketing, fashion, and funding. :)
1/3 of Go’s website on my iOS screen, is “Recent news” plus a random “featured video”. For a landing page of a programming language, This is cartoonishly bad.
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.
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.
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.
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.
Kotlin's website just opens new tabs and lost my interest in about two seconds and Go's isn't that great either. I like the new Racket webpage. It's got code, it's got links.
Haha, so true. TBH I didn't care for the previous Racket home page ... too arty farty. But at least it felt clean and current. This one, by contrast, feels totally retrograde. I wonder who made it? Hard for me to imagine a front-end designer today who would turn in work like this.
Oh god I just noticed the drop shadows on the menus ... :facepalm:
Maybe you could offer your services to make it better? Since they're a small open source community, my guess is that they don't have front-end designers of your calibre.
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.
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.
I'm also a Cal Poly graduate (computer science) who learned Racket (called PLT Scheme back when I was a Cal Poly student) from Professor John Clements (https://www.brinckerhoff.org), who was involved with PLT Scheme. We used the textbook Programming Languages: Application and Interpretation, which can be found at http://cs.brown.edu/courses/cs173/2012/book/. I'm sorry to say that at the time I took the course, I didn't appreciate it. I loved coding in C and I thought Scheme was weird. But after taking programming languages from Professor Clements, I then took his compilers course. Our first assignment was to implement a Scheme interpreter in a week. We were allowed to use any programming language we wanted. Since I was tired of Scheme, my lab partner and I decided to implement the interpreter in C++. Big mistake....we spent 40 hours on that project, building complex class inheritance hierarchies and not being able to take advantage of many of the features that made writing an interpreter in Scheme a relative breeze. I never complained about writing code in Scheme again.
When I moved on to UC Santa Cruz for grad school, my experience with Professor Clements' programming languages and compilers courses made my required graduate programming language course with type theory expert Cormac Flanagan a relatively smooth experience; going from Scheme to Haskell wasn't too difficult. Sometime afterwards I got bit very hard by the programming languages bug. I'm now working on a side project in Common Lisp, and interestingly enough, I'm actually teaching a programming language paradigms course at San Jose State University this semester where I'll be teaching my students Scheme, Prolog, and Smalltalk, as well as other goodies such as the lambda calculus.
All of this would have not been possible had I not been taught Scheme and functional programming by Professor John Clements. If he is reading this, I thank him immensely for the impact his courses have had on my career. I just wish I had appreciated the courses back when I took them, but over a decade later, I strongly appreciate them, and they're among the most valuable courses I had at Cal Poly.
It is a fantastic teaching language. So it something like Python. Except it does have very little syntax to get in the way. Close to zero syntax, in fact. You can spend 5 minutes on it, then you are off the races.
Advanced concepts (like recursion) are natural. Even more advanced concepts (like macros) are easy.
You get the understanding that code is data. Also due to that you also get 'configuration' for your application for free.
It is also a great foundation to build on. So it doesn't have OOP by default? Build your system. It will work just the same as if it were built in the language. Racket is actually notorious for being a foundation for other languages to be built upon. This very site is (or was?) built using Arc. https://en.wikipedia.org/wiki/Arc_(programming_language)
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.
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.
The community has strong emphasis on teaching. I'm just a hobbyist, but transitioning from python allowed me to improve much faster and discover new horizons.
Racket is an evolution/rebranding of a scheme variant (Dr Scheme) - or rather family of them - specifically designed for pedagogy. It's got a pretty good multiple decade history in that space, fwiw.
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."
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.
EDIT: Also, if you want a look at the dialects, check out the comic here: 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.
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.
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.
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.
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) ?
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.
I would say Lisp is a fine beginners language, but it all depends on the teacher.
One reason why SICP works so well is that the authors are very passionate about Lisp. K&R accomplishes sort of the same thing for C. Many languages have these kinds of books.
I got into Lisp from reading Paul Grahams essays and books.
One of my younger brothers eventually found his way into programming heaven via Bash scripts.
I don't think so. I've been using Lisp as long as Paul Graham, but it's not mainstream enough for a first language now. Both Lisp (of some sort) and C are better used now to extend the foundation, the former in an algorithmic direction and the latter in a computer systems architecture direction. Your first PL teaches you several things at the same time and should probably be fairly simple in all of them, a simplified exposure to lots of things at a higher level, and letting you get right into building some fun things soon--no matter how "thoughtful" you are.
Most of the top ten languages now in terms of popularity resemble one another quite a bit, and picking one of those instead of something unusual will make it easier to move quickly into whatever second language is best suited to whatever projects your thoughtful one gets attracted to. And most programming projects these days are less about algorithms than about assembling a system from components, glue code, images, etc.
I would think so, but it's hard to say. It depends on their own ability to figure things out and your ability to explain. Python is easier to google and more powerful, but Racket is like a really elegant and complete idea. I think the latter would have been more helpful when I was getting started, but it's really, really hard to say.
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."
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.
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).
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.
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.
If I had a nickel for every time I've shown someone Racket and they half-assedly respond, "Oh like Clojure"... We should be better than this as a field.
...and if you had a single clue about all that you'd know that Racket and Clojure are very different and that Racket is a strong player in the academic world.
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.