Show HN: Full Stack Lisp – A book in progress about writing Common Lisp apps

http://fullstacklisp.com/

by pavelludiq • 10 years ago

338 94 10 years ago

fullstacklisp.com

zeveb• 10 years ago

Best of luck!

I like how you mention first thinking Common Lisp was archaic, and then realising how advanced it really is.

BTW, you might want to wrap your text lines:-)

shoover• 10 years ago

+1. Kenny Tilton's blog is also great for that kind of thing.

"You know Lisp is the perfect language precisely because it lost its momentum (died) and lives on. Other languages need their Next Big Thing momentum."

http://smuglispweeny.blogspot.com/2013/08/wow-even-lispers-h...

PeCaN• 10 years ago

I think the journey of a Lisper inevitably ends up with realizing that Common Lisp is not an acceptable Lisp. Then you start searching for an acceptable Lisp. You look at Tcl, at Prolog, Io, Rebol, and Icon; you learn Shen, try Scheme and Racket, appreciate Smalltalk and Self and Slate, wrap your head around Forth and Joy and Factor… and the whole time you write Common Lisp. Because there is no acceptable Lisp.

TheMagicHorsey• 10 years ago

Is it full stack Lisp in the sense that Lisp is running on both the server and in the client (browser/mobile)?

If it is the latter, that would be quite compelling. Clojure/Clojurescript is quite compelling from a developer point of view, since you don't have to switch mental context to develop your server and client code (as you would have to do if you develop Go on the server and JS in the browser).

junke5• 10 years ago

I don't know if it will be explained in the book, but you can generate javascript from Lisp, using parenscript.

https://common-lisp.net/project/parenscript/tutorial.html

pavelludiq3• 10 years ago

I plan on covering par, but mostly the name came from an attempt to explain the current state of lisp libraries, the "stack".

e12e• 10 years ago

Interesting book. Your introduction covering toolsets, choice of lisp etc was enough that I bought a copy!

I've been seeing (common) lisp everywhere lately, from talks on clasp to the recent(ish) work on (really) fast http parser for lisp etc. It really feels like cl, with the help of a few, but very much needed tools and libraries (like quicklisp) and mature implementations that compile down to machine code could have a bit of a renaissance.

I think a lot of people simultaneously realized that one didn't have to code old style lisp, just because the cl spec has been written. Like the project to reimplement cl in cl. There's no need to rely on old broken crutches, just take the good parts of cl, combine with 40 years of experience from system and language engineering, and reduce back down to cl. And suddenly you have something very elegant and efficient and powerful.

Ok, I admit, I still want "sweet expressions"[1] -- but I think just a simple thing like acknowledging that global variables with * earmuffs * , are still global variables - and generally a bad idea -- and that cl is much more than some small "functional" language goes a long way. I remember I came to lisp rather late, and was confused by how un-functional a lot of the code was. There was just a lot of messy examples with detached functions for manipulating ad-hoc data structures that didn't seem properly motivated at all. And it all seemed terribly brittle.

But if one ignores all of that (and a lot of the classic lisp books), what emerges is that the "good" parts of cl are really great, and there's really no reason not to use those parts. And the warts in moderation (as with any other language).

[1] http://srfi.schemers.org/srfi-110/srfi-110.html

lokedhs• 10 years ago

In Potato we did exactly this. The server side is written in Common Lisp and the client side is implemented in Clojurescript.

While I have to say that it has worked pretty well, Lisp and Clojurescript are different enough that it really isn't much of a benefit to use both together. Even the S-expression format of the two languages are so different that we need to use JSON when sending messages from the server to the client (and vice versa, of course).

Please feel free to look at the code if you want to learn more about how it's done. I'll be happy to answer any questions: https://github.com/cicakhq/potato

zelcon2• 10 years ago

Lisp is a better language than Clojure. People only use Clojure out of force.

collyw2• 10 years ago

Yet a lot more stuff seems to be getting built in Clojure these days.

crispytx2• 10 years ago

Why is this on the front page of Hacker News? Isn't this an advertisement?

mordocai• 10 years ago

It's free online and has a github repo under MIT license as well... so yeah it's an advertisement but for something that you can get for free.

crispytx2• 10 years ago

I thought it was just one free chapter. Maybe I was mistaken?

dang2• 10 years ago

Work in progress is a fine thing to have on Hacker News as long as there's a way for users to check the work out. In this case there's a sample chapter, which more than clears that bar. In fact we've added "Show HN" to the title, because this is the kind of thing that Show HN is for: https://news.ycombinator.com/showhn.html

AlexeyBrin2• 10 years ago

There is actually a link to read online on the same page https://leanpub.com/fullstacklisp/read

taranw85• 10 years ago

Isn't everything an advertisement in that case? This is something cool and technical and useful.

theseatoms• 10 years ago

Exactly. HN itself is one big advertisement.

avmich• 10 years ago

Can you include a good description of reading macros? I'm still looking for good explanation with examples of their power.

xenophonf2• 10 years ago

Do you mean reader macros? Those are used to implement new kinds of syntax within Common Lisp's parser, the READ function. Even standard parts of Common Lisp syntax are defined this way, such as quote (') or backquote (`).

For more examples, see http://lisper.in/reader-macros/.

aidenn04• 10 years ago

Actually the entirety of Common Lisp's parser except for numbers, symbols, and the consing dot are implemented as read macros.

junke5• 10 years ago

A reader macro is not a kind of macros [0].

It is a way to customize the Lisp reader by associating a custom function to an entry in the readtable.

So you can say that character '[' will be tied to a custom reader function, which reads from a stream and produces a Lisp object, at readtime.

The standard sharpsign[1] character is used to read different kind of structures: complex numbers #C(0 1), structs #S(tree :left nil :right nil), and so on.

In particular, you can have sharpsign-dot, which reads a lisp form, evaluates it at read time; the result is the form being read.

Also, you can use #1= and #1# to affect parts of your code to reader variables and reuse them in other places.

If the PRINT-CIRCLE (there are earmuffs around it, but I can't format it here) variable is set to true, here is a quine:

     #1=(print '#1#)

[0] http://www.lispworks.com/documentation/HyperSpec/Body/26_glo...

[1] http://www.lispworks.com/documentation/HyperSpec/Body/02_dh....

martinflack• 10 years ago

You probably mean reader macros. Here are a few resources:

Hyperspec reference for predefined sharpsign reader macros: http://www.lispworks.com/documentation/HyperSpec/Body/02_dh....

A blog post where Vsevolod Dyomkin creates a reader macro to notate list comprehensions to his liking: http://lisp-univ-etc.blogspot.com/2013/01/real-list-comprehe...

A blog post where Inaimathi mentions using CLSQL reader macros to facilitate reading SQL expressions in code: http://langnostic.blogspot.com/2011/03/clsql-and-nothing-els...

Let Over Lambda chapter 4 which has various examples: http://letoverlambda.com/index.cl/guest/chap4.html

xyience• 10 years ago

A diagram helps when you start getting into read/compile time discussions, see slides 13 through 17 of http://www.slideshare.net/adorepump/clojure-an-introduction-... to see how the evaluation model for Clojure (which is similar enough to Lisp) differs from most other languages. One of the many differences between Clojure and Lisp though is that Lisp supports user-defined reader macro definitions, so you can add things like the nice persistent map literal syntax of Clojure to Lisp if you really want to.

baggers2• 10 years ago

I found them useful when I looked at clojure and saw their shorthand syntax for lambdas where #(* % %) is a lambda that takes one argument and squares it. You can get some tidy things that are similar with regular macros but to make it actually equivalent your need to hook into the reader..and that's what reader macros are for. So within the hour I had something that let me write λ(* _ _)

The best bit though, is that this isn't some nasty hack. This is supported by the spec, so I can package this up and let other people us it just like any other functionality we care to ship around.

That's my favorite thing really, being able to treat approaches to writing code in the same way we treat the functionality we make using code.

kazinator6• 10 years ago

That's my favorite thing really, being able to treat approaches to writing code in the same way we treat the functionality we make using code.

You mean ... programming the programming language?

I can package this up ...

Not really; it will clash with someone else's use of λ. Read macros do not "package" particularly well. (Racketlang has a good solution for this: you put a #lang whatever directive at the top of a file and then the rest of the file uses the special syntax associated with that lang name).

It's very easy to overestimate the usefulness of read syntax.

This feature of Common Lisp is used far less than newcomers might imagine, though there are some famous examples of it. If you randomly sample Lisp code, you are much more likely to find a macro than a read macro.

So within the hour I had something that let me write λ( _ _)*

Do you plan to type "lambda" with args enough times to eventually that hour of your life back? Ha.

Useful syntax for writing anonymous functions can be had, without relying on read macros at all.

cl-op: https://code.google.com/archive/p/cl-op/

Note how if we take λ(* _ _) and then just move the parenthesis over the Greek symbol, we get (λ * _ _). This saves almost the same amount of typing. If your Lisp recognizes λ as a symbol token, then all you have to do now is write a regular macro. Basically, just get the cl-op package and then set up λ as an alias for op: (defmacro λ (&rest args) `(op ,@args)).

In TXR Lisp, I implemented a more powerful op which has numbered arguments, and an escape syntax for inner ops to refer to outer ops.

Y combinator with TXR Lisp op:

  ;; The Y combinator:
  (defun y (f)
    [(op @1 @1)
     (op f (op [@@1 @@1]))])

  ;; The Y-combinator-based factorial:
  (defun fac (f)
    (do if (zerop @1)
           1
           (* @1 [f (- @1 1)])))

  ;; Test:
  (format t "~s\n" [[y fac] 4])

Combinators return us to your topic of writing a function which squares its argument. Instead of a condensed lambda notation like (op * _ _) for doing this with syntax, we can have a combinator, like (dup #'). This is nicer in a Lisp-1 language where we can just do (dup ). Dup takes its argument, which is a two-argument function, and returns a one-argument function which calls that function with two copies of the argument:

  (defun dup (fun)
    (lambda (arg) (funcall fun arg arg)))

  (funcall (dup #'*) 2) -> 4

  (mapcar (dup #'*) '(1 2 3)) -> (1 4 9)

jonathankoren• 10 years ago

It's just a macro. It's pretty much exactly like a #define in C

junke5• 10 years ago

They only share the name.

_ph_• 10 years ago

This is pretty much wrong. C macros have a simple substitution language. But all Common Lisp macros can run arbitrary common lisp functions to compute the macro expansion. That means, you are not limited to pattern matching, but can write a program - in the same programming language you are using for your application - to compute the expansion. Of course there are simple cases which are just syntax rewrites, but there are also complex cases, like the loop macro. The loop macro allows you to specify looping constructs in an almost natural language.

sedachv• 10 years ago

Read macros are great because you can use them to turn the Common Lisp parser into a parser for any language you want (no restrictions on the grammar), so you essentially get compilers for free. I wrote a one-pass C preprocessor and parser in just under a thousand lines of code: https://github.com/vsedach/Vacietis/blob/master/compiler/rea...

kazinator6• 10 years ago

Poor cover art.

How about fitting, into a single image, a joke about some ex-web developer, stacking pancakes at IHOP.

Or maybe a visual reference to this type of full stack: https://www.google.com/search?q=guitar+full+stack&tbm=isch

imglorp• 10 years ago

The critter is a reference to http://landoflisp.com/

TimJRobinson• 10 years ago

I'd love to see more books like this for less common languages (Haskell particularly), as I've found there's generally plenty of resources for learning the basic commands and code structure but there's little information for going from those first steps to creating an actual useful application.

xwowsersx• 10 years ago

Working on a video course https://www.youtube.com/watch?v=04ZZKFcpUoo though there is also a great book for Haskell now http://haskellbook.com/

sharmajai• 10 years ago

I believe this is one of the major goals of http://book.realworldhaskell.org/read/

With this book, we want to show you how to use functional programming and Haskell to solve realistic problems. This is a hands-on book: every chapter contains dozens of code samples, and many contain complete applications.

vog• 10 years ago

There's also a similar book for OCaml:

https://realworldocaml.org/

seagreen• 10 years ago

Real World Haskell is somewhat out of date. I'm not sure what to go with instead, but I've heard good things about Haskell Programming from First Principles (which has already been mentioned in this thread).

marcosdumay• 10 years ago

Unfortunately, that book is dated. It's not even that old, but it's already dated.

Haskell has a discoverability problem, and a good modern book might be the best way to solve it. But it may be moving too fast for that currently.

cadr2• 10 years ago

Just a nitpick, but I find the code part hard to read. Not sure if it is the colors or what. You might get some other feedback on it. Good luck!

tropo• 10 years ago

It's just the language. Everything looks the same.

cadr2• 10 years ago

No, I'm use to reading Lisp. Something else, but I'm not a designer and can't quite put my finger on it.

wtbob3• 10 years ago

Agreed. I think that the line numbers and machine-inserted hard breaks make it difficult to read. For the first issue, maybe the line numbers could be smaller and/or greyer, and offset more? For the second, I think human editing of the lines is probably required.

AlexeyBrin2• 10 years ago

The book can be read online, link is easy to miss but it is there https://leanpub.com/fullstacklisp/read

valbaca• 10 years ago

or click on the book cover. hard to miss

Wonnk13• 10 years ago

I missed it ...

auvi• 10 years ago

I really appreciate the author taking the time to write this book. I have read his previous book Lisp Web Tales and learned many things from it.

mark_l_watson2• 10 years ago

Very nice, I love seeing new Common Lisp books being written. (BTW, I also have a Common Lisp book on leanpub.com - a great company to work with if you are a writer).

It is especially good to see a complete caveman2 application developed in the book.

eggy2• 10 years ago

I am in the middle of reading Adam Tornhill's 'Lisp for the Web', and I just stumbled on this book.

Yes, Lisp seems to me to be getting more exposure, but that may be my 'Lisp-colored sunglasses' ;)

Is caveman2 a lot easier, or what other advantages does it have over piecing stuff together?

I have always liked and programmed in Lisp, but not for the Web, so I need to get up to speed with Web frontend/backend programming again for personal use, not a job.

OT: Mark, I am on your 3 edition of 'Loving Common Lisp', and I really appreciate the Networking chapter update, and your smooth writing style!

deckard1• 10 years ago

or you realize Perl, Ruby, Python give you everything good from Lisp anyway with an environment and packages that can talk to the real world, and that macros and metaprogramming are massively overrated and a danger in almost any hands that touch those features.

Ask me how long I spent banging my head against the wall trying to get OpenGL working in CMUCL with Alien. Jesus jumping-jack Christ. I can only hope things have improved in the past 12 years or so. But I highly doubt it.

pavelludiq3• 10 years ago

I did python professional y for a few years and I missed lisp every day. There is much work to be done, but lisp has improved tremendously in the last decade.

nilkn• 10 years ago

I don't think that's true. For instance, Python has traditionally been really bad for concurrency but Lisp can be best-in-class (see Clojure's STM). Python is good for single-threaded concurrency now with coroutines and libraries like asyncio, but it still can't compete with something like STM for multithreaded concurrency.

PuercoPop• 10 years ago

Why look at clojure's STM and not CL? https://github.com/cosmos72/stmx

pjmlp• 10 years ago

Perl, Ruby, Python give you everything good from Lisp

So where are the:

- AOT compilers to native code

- REPL environments with GUI debuggers, with fix-and-continue?

- Ability to do systems programming without having to use an external language?

- Macros

dang2• 10 years ago

We detached this subthread from https://news.ycombinator.com/item?id=11825955 and marked it off-topic.

We gave you the benefit of the doubt originally, despite the nasty embers burning in your comment, but then you went full flamewar downthread. We don't want that on HN, so please don't do it again.

zelcon2• 10 years ago

I recently gave up Lisp for Clojure instead because of the dearth of "batteries," so this book is very important and timely.

haspok4• 10 years ago

I'd love to read a chapter about why would someone choose Common Lisp instead of, say, Clojure (with all the JVM ecosystem behind it) or LFE (with the Erlang ecosystem behind it). What are the use cases in which CLISP stands out and offers a benefit?

junke5• 10 years ago

First, you should not abbreviate Common Lisp as CLISP: this is confusing because CLISP is one of the many implementations of CL.

As for comparisons, this is a Gorilla vs Shark problem (https://blog.stackoverflow.com/2011/08/gorilla-vs-shark/), without context you can choose anything you prefer.

LFE is not really Lisp, it is more like Erlang with parenthesis, so it is hardly comparable. Erlang offers a very specific, and useful, model of computation: if you need that, use Erlang or LTE.

In CL vs. Clojure, I suppose CL looks riskier to use than Clojure, w.r.t. all those JVM libraries (and the coolness factor). I think this is false, because you can access Java/Clojure/C libraries from CL with ABCL/CFFI, whereas you cannot access the Common Lisp ecosystem from Clojure easily.

But in the end, which programming language you use depends on many factors.

haspok4• 10 years ago

Let me try to rephrase my question: I know what I can use Clojure or LFE/Erlang for and what their strengths/weaknesses are. I don't really know anything about Common LISP other than it is a LISP, so I would love to hear some factors that led some people to prefer Common LISP to anything else out there (other than personal preference, which is always a factor).

Is it good at number crunching (which is not Clojure's and definitely not Erlang's forte)? Is it good at low level systems programming? Is it good for computers with low memory resources? Etc. In your words, I am looking for the context.

Elrac• 10 years ago

Disclaimer: Amateur's blundering travelog.

I've been dabbling in Clojure for about 4 years now, off and on, and it works very well for small-ish projects. The integration, as others have mentioned, with the JVM is superbly seamless (it leaves Scala in the dust in this respect) and this opens up most of the Java ecosystem. Also, the STM model of concurrency management is super cool. So far so great!

But every time I try to build something more substantial than a Project Euler submission, I end up with something blowing up in my face. Recently, I was a bit annoyed to discover that the set of keys of a map doesn't have the same semantics (including sequential access) as other sets, and on another occasion I was debugging something and the contents of some variables that displayed valid data in "print" statements showed as "null" in my debugger. None of this is show stopping but when I'm just playing around I have a low frustration threshold. My impression is that Clojure is a good Lisp with many fantastic new features but not all of the batteries are included (yet).

Meanwhile, I have zero experience with CL but I keep hearing that it's highly mature, rock solid, the choice of most professional Lispers, and the platform of choice for Peter Norvig's book on AI programming. In my imagination, that means everything works exactly as expected and there is a wealth of useful libraries - which would be sweet, from where I stand.

eklavya• 10 years ago

"... with the JVM is superbly seamless (it leaves Scala in the dust in this respect) ..."

Uh, what?

haspok4• 10 years ago

Clojure seems to be a natural choice for microservices, but I never used it for anything on a larger scale. Good point, if it is something Common LISP gets right it is definitely worth a look!

wtbob3• 10 years ago

Meanwhile, I have zero experience with CL but I keep hearing that it's highly mature, rock solid, the choice of most professional Lispers, and the platform of choice for Peter Norvig's book on AI programming.

It is definitely highly mature, rock solid and the choice of most professional Lispers. It anticipates many problems one doesn't even know one will have, and solves them.

In the negative column, it's a bit crufty for historical reasons (e.g. (aref ARRAY 1 2) vice (gethash KEY HASH-TABLE)) and made some choices which in retrospect were foolish (upcasing symbols being a huge one). The former doesn't really matter, and the latter can be solved with a simple (setf print-case :downcase).

For a long time, there were few good resources for learning Lisp. Fortunately, that's changed. Peter Seibel's Practical Common Lisp (http://www.gigamonkeys.com/book/) is a must-read: it explains a little of why Lisp is so relevant for modern development. Edi Weitz's new book Common Lisp Recipes (http://weitz.de/cl-recipes/) is worth its weight in gold.

Quicklisp (https://www.quicklisp.org/beta/) is a great place to find a lot of great packages.

mark_l_watson2• 10 years ago

Some advice for Clojure that applies to all lisps: write code bottom up in small pieces making heavy use of the repl for development. Really understand what your small piece of code does, clean it up, put it in a separate small file, and once you have confidence in it think of it as a library that just works.

Show HN: Full Stack Lisp – A book in progress about writing Common Lisp apps

Related Stories