Hacker News Reader

Comment by andrenth | Hacker News Reader

Re statically typed Lisp, I’m keeping an eye on Carp [1] which seems to be a quite active project.

Common lisp meets Rust, I'm intrigued.

All these new exciting programming languages over the past ~5 years or so are quit exciting. I'm starting to believe that in the not so far future we'll look back on that time period between the late 90s up to the mid 2010s as some kind of a dark age for programming, where we kept using those inelegant, inefficient, hacky languages carried by Moore's law and an incredible demand for new software being written in huge quantity extremely fast, quality be damned.

Now that the gold rush starts to cool down there seem to be a lot of very interesting work to take a few steps back and do it right.

I think your dark age and gold rush theory has some truth to it. The whole industry culture and practices changed during that period, but we're starting to see things like people interested in Rust, even though it's not pitched as a faster way to make slicker generic Web sites and phone apps.

I'm also hoping that Racket (which is is like a secret oasis community) will get more attention, and someone will dust off some old Paul Graham writings about startups and Lisp, and some startups (probably ones who're not just doing another cookie-cutter madlibs startup) will decide to use Racket initially. (Disclosure: I have an interest in promoting Racket, because I'd love to help build startups in Racket, and also recruit top programmers with Racket as a carrot.)

What do you think are good learning resources for learning racket for an experienced (functional) programmer? Is there a book that isn’t focused on learning to program?

Are you experienced in Common Lisp? Racket is multiparadigm too.

As such, many good multiparadigm books will be of great help. E.g. SICP, but also the much less known yet equally fantastic CTM. None are written in Racket, although SICP with Scheme is close, but many concepts can be ported.

There's also excellent Lisp literature like Lisp in Small Pieces or PAIP, that are always worth to consider.

Racket also implements most of http://www.eopl3.com/, which is a great textbook.

Thanks. I don’t know Common Lisp, but I guess the knowledge will be transferable.

quick read https://github.com/a-guile-mind/book/#a-guile-mind-book

For working through SICP, you can actually use the Racket tools, like the DrRacket IDE. We rigged up a simple `#lang sicp` that emulates the version of MIT Scheme used for SICP problem sets: https://docs.racket-lang.org/sicp-manual/

For an FP person, you might want to instead start with skimming, for half an hour, the R5RS or R7RS Scheme paper, for the base language from which Racket grew (don't worry about the first-class continuations unless you want to). Then go to the Racket Guide or Racket Reference table of contents, to look for things that you might be looking for from your past FP experience, like `match` (though it's maybe not used as much as you're familiar with). Then look into some of the strengths of Racket, like syntax extension and `#lang`. (If you want additional treatment of syntax extension and `#lang`, see things like Hendershott's "Fear of Macros", and Butterick's book.) Also skim the large list of add-on packages, to get a sense of what's there. Eventually read through the Guide and Reference at your leisure.

There's an imposing wall of manuals at: https://docs.racket-lang.org/

Racket isn't purely FP, but it can be used that way, even with the base language. There's also at least one lazy `#lang`, and you can make more.

Thanks! Just adding a link to Butterick’s book, “Beautiful Racket”: https://beautifulracket.com/

Oh, you might like another difference between Racket and R5RS Scheme: Racket has changed some basic Scheme types, like pairs/lists, to be immutable by default. And various additional Racket types, like `struct`s, also have both immutable and mutable variants and parts.

I am planning to kick off a biotech startup this Fall around a great idea / discovery, and it will be done in Lisp. Probably in Racket.

I already received some cool VC funding offers. I'm evaluating them, and planning stuff.

For my use case, Racket is perfect, so it has big chances.

As you're looking for co-founders and/or early hires or consultants, definitely post to the `racket-users` email list (currently also a Google Group), which is the most canonical forum for Racket.

And feel encouraged to email me directly. I might be available then myself, and, if I can get some understanding of your needs, I might also know some other good candidates.

I will do both things, thanks for the tips!

What development tooling do you use for Racket? I tried Dr. Racket and it felt pretty janky compared to SLIME for CL.

Try this https://www.racket-mode.com/

After working a lot with statically typed languages, I’ve been doing some work recently with a dynamic language, and it feels refreshingly fun...

Granted, I’ve been using elixir and erlang, where the use of pattern matching matching and immutability give you a lot of the benefits that modern static languages have, but I wouldn’t mind a new wave of modern dynamic languages, or at least static ones that feel more dynamic (Carp may fit in that spot).

If you haven't looked at it, then (lisp (flavoured (Erlang))) will appeal to you. [1]

[1] http://lfe.io

Research languages like Mesa/Cedar or Modula-3.

We had a dark age of too much VM and scripting languages, and only now getting back how computing could have looked like.

For example, given Anders background imagine how .NET would have been if it was fully AOT compiled and the same low level features from Delphi since version 1.0.

Or if C++ Builder wasn't the only surviving example to RAD development with C++, before others started to build on top of LLVM toolchain.

There’s also Coalton — a typed implementation within Common Lisp https://github.com/stylewarning/coalton/

Another is clasp https://github.com/clasp-developers/clasp

There are a few interesting talks on yt: https://www.youtube.com/watch?v=mbdXeRBbgDM

Oh man this is going to be a fun naming conflict to resolve... https://github.com/google/clasp

Reply on news.ycombinator.com