Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

The Roots of Lisp (2001)

paulgraham.com

Post reply on HN
Print view View original

21–30 of 92 posts

Re: The Roots of Lisp (2001)

#21

Post by psychoslave »

Nokinside wrote: post #13
coder1001 wrote: post #2

It amazes me how @pg managed to conquer the business side of startups and started YC given his very technical background! To me it is not very common for (very) technical people to be good at both tech and business!

I'm electronics and embedded software developer, but I took a pause from that and founded a small web business startup with few guys two years before PG founded Viaweb. The product was very similar to PG 's Viaweb. Viaweb was more general and consumer market oriented. We had narrow focus with b2b trough our connections. It's hard to describe how easy it was to make money in the late 90's with even little technical sk…

Does PR stands for Purchase Request here?

Re: The Roots of Lisp (2001)

#22

Post by LandR »

jecel wrote: post #19
coldtea wrote: post #11

Earlier quoted context omitted.

"Some good concepts"? It was the first language to add "if/else" constructs, GC, closures, first class functions, reference semantics, and recursion. It took between 5 to 40 years before these became available in mainstream languages (conditionals like if/else were adopted early, GC not so much, closures took even more). Add to that macros and the flexibility of runtime evaluation / code creation, which most mainstre…

One small detail - though COND and IF/ELSE are very closely related, they aren't quite the same thing. Early Smalltalk also started out with COND (a right arrow which made code look like modern switch/case) and later evolved to #ifTrue:ifFalse: which is still postfix, so feels backwards compared to other languages. Lisp and Scheme got more conventional if/else eventually.

Something I discovered about Clojure's cond recently.

It usually looks likethis:

    (cond ( a b) (println "a > b")
          :else   (println "a = b"))
I thought the :else had to be :else, but it only needs to be truthy, so it can be anything that isn't false or nil (which makes sense as you want it to always execute that form if no others match).

So this is just the same:

   (cond ( a b) (println "a > b")
         :hotdog (println "a = b"))
Probably obvious to everyone else but it was a bit of a "duh, of course!" moment for me.

Re: The Roots of Lisp (2001)

#23

Post by cercatrova »

psychoslave wrote: post #21
Nokinside wrote: post #13

Earlier quoted context omitted.

I'm electronics and embedded software developer, but I took a pause from that and founded a small web business startup with few guys two years before PG founded Viaweb. The product was very similar to PG 's Viaweb. Viaweb was more general and consumer market oriented. We had narrow focus with b2b trough our connections. It's hard to describe how easy it was to make money in the late 90's with even little technical sk…

Does PR stands for Purchase Request here?

Public relations.

See related: http://www.paulgraham.com/submarine.html

Re: The Roots of Lisp (2001)

#24

Post by yters »

If I look at the operon structure of a genome, and squint a bit, it looks very similar to the LISP structure:

(func var0 var1 ... varn)

Could it be that the design of LISP is inspired by the structure of the genetic code?

Re: The Roots of Lisp (2001)

#25

Post by sparkie »

LandR wrote: post #22
jecel wrote: post #19

Earlier quoted context omitted.

One small detail - though COND and IF/ELSE are very closely related, they aren't quite the same thing. Early Smalltalk also started out with COND (a right arrow which made code look like modern switch/case) and later evolved to #ifTrue:ifFalse: which is still postfix, so feels backwards compared to other languages. Lisp and Scheme got more conventional if/else eventually.

Something I discovered about Clojure's cond recently. It usually looks likethis: (cond ( a b) (println "a > b") :else (println "a = b")) I thought the :else had to be :else, but it only needs to be truthy, so it can be anything that isn't false or nil (which makes sense as you want it to always execute that form if no others match). So this is just the same: (cond ( a b) (println "a > b") :hotdog (println "a = b")) P…

It's conventional in Scheme and Lisp to just use `#t` directly to match anything.

Re: The Roots of Lisp (2001)

#26

Post by abhiyerra »

yters wrote: post #24

If I look at the operon structure of a genome, and squint a bit, it looks very similar to the LISP structure: (func var0 var1 ... varn) Could it be that the design of LISP is inspired by the structure of the genetic code?

I always thought this as well. In Lisp, data is the program similar to how DNA is data as well as the program.

Re: The Roots of Lisp (2001)

#27

Post by ctkrohn »

Funny to see this after all these years. I read this paper just before starting college in 2003 and it inspired me to spend most of the summer writing a rudimentary Lisp interpreter in rudimentary C++. That was my first piece of my code that actually worked, and was more than a dozen or so lines. Good memories.

Re: The Roots of Lisp (2001)

#28

Post by Joker_vD »

coldtea wrote: post #11
terminaljunkid wrote: post #9

IMO Lisp is just overrated, it lacks visual clues, reads right to left with horrible nesting etc.. Sure it has some good concepts. But fanboys on internet make it seem like some God tier thing.

"Some good concepts"? It was the first language to add "if/else" constructs, GC, closures, first class functions, reference semantics, and recursion. It took between 5 to 40 years before these became available in mainstream languages (conditionals like if/else were adopted early, GC not so much, closures took even more). Add to that macros and the flexibility of runtime evaluation / code creation, which most mainstre…

> It was the first language to add "if/else" constructs, GC, closures, first class functions, reference semantics, and recursion.

"Lisp is still #1 for key algorithmic techniques, such as recursion and condescension."

Re: The Roots of Lisp (2001)

#29

Post by allenu »

fouc wrote: post #4
coder1001 wrote: post #2

It amazes me how @pg managed to conquer the business side of startups and started YC given his very technical background! To me it is not very common for (very) technical people to be good at both tech and business!

Yet some of the most successful business people seem to be good at tech. I heard that half of the CEOs of the top 500 fortune companies have a STEM degree.

There might be some survivorship bias in there if STEM fields are more successful than others, naturally leading to more STEM leaders, or more opportunities for leaders to form.

Re: The Roots of Lisp (2001)

#30

Post by lispm »

LandR wrote: post #22
jecel wrote: post #19

Earlier quoted context omitted.

One small detail - though COND and IF/ELSE are very closely related, they aren't quite the same thing. Early Smalltalk also started out with COND (a right arrow which made code look like modern switch/case) and later evolved to #ifTrue:ifFalse: which is still postfix, so feels backwards compared to other languages. Lisp and Scheme got more conventional if/else eventually.

Something I discovered about Clojure's cond recently. It usually looks likethis: (cond ( a b) (println "a > b") :else (println "a = b")) I thought the :else had to be :else, but it only needs to be truthy, so it can be anything that isn't false or nil (which makes sense as you want it to always execute that form if no others match). So this is just the same: (cond ( a b) (println "a > b") :hotdog (println "a = b")) P…

In Lisp usually all non-nil values mean true.

  CL-USER 13 > (let ((a 1) (b 2))
                 (cond ((> a b) 'foo)
                       (:hello :there)))
  :THERE
In some early Lisp dialects not all objects (other than lists and symbols) would be self-evaluating, so one would have to quote them.
Post reply on HN