Hacker News Reader

Comment by peller | Hacker News Reader

I remember trying do do that years ago, and getting hung up as a newbie on there being a million different LISP implementations. I think I tried to use Racket, if I remember correctly, but whatever I picked didn't support some of the book's LISP statements out of the box. Any recommendations for a more friction-free experience?

View on HN

I remember trying to learn a garbage-collected language with curly braced blocks, functions and infix operators years ago, but was hung up on there being a million implementations. I think I tried to use Java, but was hung up on the book's C# statements that weren't supported out of the box. Any recommendations for a more-friction free experience?

How about this recommendation: use the exact same language that your book or tutorial teaches!

Racket has even gone out of its way not to be named Scheme (it was a Scheme once called PLT Scheme, but changed its name). Scheme, in turn, went out of its way not to be named Lisp.

A tutorial that purports to be about Lisp is quite probably about a traditional language which has characteristics such as the symbol nil being a self-evaluating expression representing the empty list and Boolean false.

I don't think this is a fair comparison to what the GP is saying. You can pick up pretty much any book on programming for the C-style and more then 90% of the information will transfer over. Classes may be omitted in some, reqired in others. The same may apply to types. But after they see a compiler warning you're likely to google it and figure out what's wrong very easily.

On the other hand most people, who are quite professional in our field I might add, don't even know the names of the most used LISP derivatives. Many also don't even realize they have one built into their browser that is perfectly adequate for satisfying the desires to explore functional programming and general computation principles.

This isn't a statement of malice or even a bad question from the GP. It is confusing and we only have ourselves to blame for this (ourselves being the world of people who want FP to become more mainstream in the SE world).

Look at the stark differences in these two websites:

   - http://racket-lang.org/
   - https://www.rust-lang.org/

What we need is this (with much less crap):

   - https://www.python.org/

And what we don't need is this (with all of this text and few examples of what you CAN do):

   - http://julialang.org/

Granted these are for different markets but the point still stands. If you want adoption by the general software development communities we must make a good case as to why this move should be made. Historically this required a few factors

   1. A better alternative to at least 1 problem *
   2. A simple unified way of introducing people to the change
   3. Simple support for the rollover. Or at least simple enough as to not overpower the benifits presented by switching over.

* = Something that has already been done by the FP community.

You have to understand that peeople call it like they see it and when they see Lots of Insane and Silly Parrens they see LISP and no name change will disaccosiate Scheme, Racket, and LISP in the eyes of the average programmer. I've been using functional languages for a good part of my life as a programmer and I feel they ARE the same. The ideas are common even if their presentation isn't.

The only LISP-Like languages that have sucessfully hid from the tarnished name of LISP are JavaScript and Python and they've managed to develop their own bad raps for themselves in the eyes of some programmers.

No progress will be made by barrating people. Prucussive maintence works on tools and gear, not peers.

>"Many also don't even realize they have one built into their browser that is perfectly adequate for satisfying the desires to explore functional programming and general computation principles."

Are you referring to Javascript being a LISP dialect here? I've heard this occasionally but I also though that the one predominant feature of LISP was that of homoiconicity which I don't believe applies to Javascript or is that not correct? Thanks.

JavaScript IS lisp with 1) a new syntax and 2) more things bolted on top that make it a non-LISP language. There are two things under the catagory of JavaScript. The Functional size and the Imperative side. It's the only language in the lisp family that allows you to write both, neither, or some combination in the same program. I say neither because other paradigms can be expressed from within JavaScript that will not be expressable in most FP and Imperative languages without some muscle involved in forcing it to do so.

Watch David C.'s talk on JavaScript the Good Parts to see this diamond in the rough.

> It's the only language in the lisp family that allows you to write both, neither, or some combination in the same program.

Where did you get that from?

Almost all Lisp dialects allow you to write functional and/or imperative code.

I will give this talk a watch, thanks.

I can't seem to find this talk anywhere on the internet.

Racket has an SICP plugin that makes everything from the book work.

Racket is much less approchable for people. I can't figure that mess out. Many people seem to find it difficult to endorse "get started and go" mentalities. The reason for N language implementations in Racket is that many LISP programmers are big fans of Domain Specific Languages (DSL) and this is also something that is taught in SICP.

Edition 2 of SICP was reimplemented in Common Lisp [0] (more specifically ANSI Common Lisp). Common Lisp is to Racket/Scheme/JavaScript/Clojure as C is to Rust/Java/Python/C++. It isn't the only way to implement a language and no one will say it's the "best" when compaired to My Favorite Implementation (TM) but everything draws from it and everything influenced it at the same time. It's the common ground that everyone can hold a leg on and knowing it will be your Rosetta Stone.

One common implementation is CLISP which is a GNU package.

To find out how everything works it is recommended that you attempt to read through the UNIX man page on the operation of this program. You will better understand how to interface with the program then. If you've used python then you will instantly recognize the idea of the REPL. [1]

If you have a software development background then [2] is probably all you need to get started. If not, as I have mentioned, you can check out SICP [3] as the book is online for no cost on an MIT website. Reading through this, maybe even one chapter per day, and doing the exercises as the book tells you to will give you a solid understanding of the concepts.

[0] - https://en.wikipedia.org/wiki/Common_Lisp

[1] - http://www.clisp.org/impnotes/clisp.html

[2] - https://en.wikipedia.org/wiki/Common_Lisp#Syntax

[3] - https://mitpress.mit.edu/sicp/full-text/book/book.html

CLISP is redistributed under the GPL, but isn't part of the GNU project.

GNU project's Common Lisp implementation is a project called GCL: GNU Common Lisp, a descendant of Kyoto Common Lisp.

Also, your analogy that Common Lisp to various Schemes and Clojure is like C to Java/Rust/Python is severely flawed in multiple ways.

I am curious do you have a different suggestion for a LISP implementation for working through SICP other than CLISP or would you agree this is a good choice?

SICP is squarely based in Scheme. One of the two authors of SICP is Gerald Sussman. Sussman, together with his then student, Guy Steele, invented Scheme.

Thanks.

Reply on news.ycombinator.com