New Racket Language Website

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

And don't forget this beautiful book on Racket, https://beautifulracket.com/

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. :-(

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.

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.

> made in Photoshop in the mid-00s

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:

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):

https://groups.google.com/forum/#!topic/racket-dev/kJciZheDM...

I think a few pretty ordinary challenges are:

* 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] One notable exception in Racket, though I don't know whether involved with the new site, is Matthew Butterick, as a diversely multi-skilled person. He did a lot of visual/graphic design work on other Racket stuff, which you can see by contrasting the old look of the documentation, with the current one. Old: http://planet.racket-lang.org/package-source/neil/roomba.plt... Current: https://docs.racket-lang.org/roomba/index.html

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.

Language websites are meaningless to me.

I pick languages based on frameworks and platform SDKs.

The language is a side effect of the ecosystem being targeted.

Otherwise it is just like picking books based on the cover.

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

Yep it looks great, really crisp - +1 for the play section!

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.

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.

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.

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 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)

> 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...

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.

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

https://i.imgur.com/KLSZ33H.png https://i.imgur.com/b9HXnfj.png

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

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.

My point is the medium matters less.

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.

It could be but I think python would be better.

YES! Check out Bootstrap and How to Design Programs.

https://www.bootstrapworld.org/ https://htdp.org/

You might also like Pyret: https://www.pyret.org/

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.

There is a two part course on edx.org taught by Gregor Kiczales. The first one is called How to Code Simple Data.

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.

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."

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

Yep, will even say is the best enviroment for SICP.

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

I found this SICP guide helpful in terms of choosing which lisp to work through the book: https://github.com/zv/SICP-guile

yes see https://docs.racket-lang.org/sicp-manual/

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).

Its in the footer: https://blog.racket-lang.org/

If you click the "Community" tab it is listed. More hidden than it used to be.

The code is correct. That's a Lisp thing called `quote`. https://docs.racket-lang.org/guide/Pairs__Lists__and_Racket_...

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 you have nothing productive to say, don't comment. It really is that simple.

And Racket is almost a decade older than Clojure.

...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.

Was this sarcasm?

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.