11 ms·
The Roots of Lisp (2001)
- yters 7y agoIf 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?
- coder1001 7y agoIt 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!
- fouc 7y agoYet 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.
- Hendrikto 7y agoMy guess: STEM degrees require and foster critical thinking, logic, and abstraction skills, which are all very conducive to being a good business person.
- allenu 7y agoThere 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.
- coldtea 7y agoFor some counter examples: Bill Joy co-founded SUN - but also wrote ex, vi, the BSD UNIX tcp/ip stack, and other things. Marc Andreessen wrote Mosaic and Netscape - and is a famous VC person now (of Andreessen Horowitz fame). Bill Gates, also very technical (wrote early MS programs, BASIC interpreters etc). Eric Schmidt (ex Google CEO) wrote Lex (the lexer, now more known by its GNU port, flex) and was SUN's first programmer.
- tabtab 7y agoEarly Microsoft tended to clone or buy successful products. They were not really into core R&D, only improvement R&D. They let others be the guinea pigs. Gates was a skilled poker player, which probably helped him be a shrewd business-person. When all was said and done, you would realize he walked away with all your best cards.
- Nokinside 7y agoI'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 skill and tiniest amount of business understanding. We were making money hand over fist knowing next to nothing. PG sold his company for $50 million, we sold ours for $5 million after we took the mountain of cash out of it (another $5 million). After reading how PG did it, I think his genius was paying $16,000 a month for a PR firm. He understood the value of PR, we didn't. http://www.paulgraham.com/submarine.html http://www.paulgraham.com/submarine.html His essays, HackerNews and Y combinator are expression of this understanding. He has created expanding self-reinforcing network of affordable PR and connections for startups. That's the real scarcity in the startup scene. Being accepted into a batch is valuable. Instead of hiring PR firm, PR firm accepts you and stamps you with the Y Combinator brand.
- psychoslave 7y agoDoes PR stands for Purchase Request here?
- cercatrova 7y agoPublic relations. See related: http://www.paulgraham.com/submarine.html http://www.paulgraham.com/submarine.html
- tabtab 7y agoOften times it's a matter of just listening to customers. Even if you don't have a knack for the domain, if you get enough feedback and react to it, you can "organically" fit it well. It's sort of comparable to a genetic algorithm. Of course, having a knack for a domain could mean fewer iterations of rework. Lisp is ideal for changing on a dime, at least for a small team.
- LanceH 7y agoIt's not very common for anyone to be good at business. But for some reason when people are good at tech, suddenly that becomes the reason they are bad at business.
- bsaul 7y agoRecently had a conversation on how functional programming and declarative programming were somewhat linked, and how i observed that languages that started to go down the functional road slowly tried to add more and more capabilities for DSLs, and then slowly moved toward becoming a lisp. But that was just my feeling. is this theorized somewhere ? Or am i just dreaming ?
- try_again 7y agoA well-known quote is that whoever doesn't understand Lisp is doomed to reinvent it: http://lambda-the-ultimate.org/node/2352 http://lambda-the-ultimate.org/node/2352
- deepaksurti 7y agoGreenspun tenth rule may come into play here [1] [1] https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule
- dgb23 7y agoAnecdotal experience: (dynamic) functional programming enables very 'easy' succinct abstractions through combing out concretions and composing functions out of a general tool-set. Think code-reuse in the small. With some discipline you naturally end up with a very data-oriented codebase, where the specificity of your application/library ends up in your data-structures. Now these data-structures are really just plain data, without specific behavior attached to them, so they embody the (maybe almost) declarative part of your program/system. The next step would be to polish them to make them more human readable. An additional feature of Lisps is their homoiconicity and macros. These come into play when plain data-structures are not the right fit anymore. Typically you want to handle some user/client defined behavior. You can now transform the syntax of the language itself to clean up your API to reduce boilerplate and increase readability. In a sense you have now programmed your own DSL.
- terminaljunkid 7y agoIMO 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.
- coldtea 7y ago"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 mainstream languages still lack. And of course, Lisp's rules remain (and will always be) the most succinct way to define a full blown programming language with meta-programming facilities to boot -- as opposed to a mere Turing machine like thing or assembler. >IMO Lisp is just overrated, it lacks visual clues, reads right to left with horrible nesting etc.. This doesn't make any sense... The nesting is the same as in almost any language. "reads right to left" - huh? You know that Lisp code can be indented right?
- Joker_vD 7y ago> 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."
- lkschubert8 7y agoI think they are referring to the nested nature of lisp function calls. (second-fn (first-fn val)) I think that is really just personal preference/what you were taught as opposed to good or bad language design. But it really doesn't matter as one of the big benefits of lisp is it's ability to be metaprogrammed. That same example could be rewritten in clojure as (-> val first-fn second-fn) thanks to macros and doesn't suffer from the right->left reading.
- 7y ago
- tromp 7y ago> In 1960, John McCarthy published a remarkable paper in which he did for programming something like what Euclid did for geometry. One could argue that Church's (1930s) lambda calculus, which underlies LISP, is a closer analogue to Euclid's distillation of the essence of Geometry. With the minimal addition of pure binary IO, the lambda calculus is easily transformed into an untyped programming language [1]. On the other hand, full blown and richly typed pure functional programming languages like Haskell remain semantically faithful to their lambda calculus underpinnings. [1] https://tromp.github.io/cl/Binary_lambda_calculus.html https://tromp.github.io/cl/Binary_lambda_calculus.html
- lisper 7y agoCool! You might enjoy this: http://www.flownet.com/ron/lambda-calculus.html http://www.flownet.com/ron/lambda-calculus.html [EDIT] Heh, I just realized that we corresponded on this back when I wrote it in 2014! Small world.
- nikofeyn 7y agoi don't think it's accurate to say lambda calculus underlies lisp, is it? certainly lambda calculus was used to define functions in lisp, as seen in the original lisp paper (or the most famous one). http://jmc.stanford.edu/articles/recursive.html http://jmc.stanford.edu/articles/recursive.html lambda calculus was a tool, but it seems godel and turing's work on computing machines and recursive functions were more fundamental to the original lisp.
- curious_yogurt 7y agoThe claim seems accurate to me, at least for Scheme: that is, lambda calculus does underlie Scheme. Lambda calculus, as articulated in Church's 1935 paper, gives us a way to understand computability. But if we look specifically at Operation II in the paper (p. 347), what we have is the lambda function in Scheme. Given that every function in Scheme (including special forms) is equivalent to some lambda function, it seems that in virtue of Operation II we can say that lambda calculus underlies Scheme. Whether we can push this further to say that lambda calculus underlies McCarthy's initial conception of LISP, or some arbitrary version of Common Lisp, I do not know for certain. But if all these versions treat lambda functions the same way as Scheme does (in relevant respects), then the claim holds for Lisp generally. [1]: Church. An Unsolvable Problem of Elementary Number Theory. _American Journal of Mathematics_, Vol. 58, No. 2. (Apr., 1936), pp. 345-363.
- TruffleLabs 7y agoMcCarthy wasn’t just interested in making Lisp for AI, he was thinking about the possible applications AI, with Lisp as a platform to get to more advanced states of understanding. An example of this is in his paper “Computer Control of a Machine for Exploring Mars." Stanford Artificial Intelligence Project, Memo N. 14, June 15, 1964, Author: McCarthy, John, 1927-2011; Stanford University Library collections. https://stacks.stanford.edu/file/druid:qh147kq8662/SC1041_SAIL_AIM_014.pdf https://stacks.stanford.edu/file/druid:qh147kq8662/SC1041_SA...
- ctkrohn 7y agoFunny 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.
- jammygit 7y agoWhich is the better introduction to Lisp: On Lisp (by pg), SICP, or another text (maybe on Common Lisp)? Or is it better to just go straight to Clojure these days?
- armitron 7y agoOn Lisp is an advanced text about Lisp macros, not recommended as an introduction (but highly recommended if you've written Common Lisp). SICP is great but not really about Lisp. I recommend Norvig's PAIP [1] or Graham's ANSI Common Lisp [2]. Another book that's often recommended is Practical Common Lisp but I think it's dated and hasn't aged well. It's also nowhere near as mind expanding as PAIP/Graham's books. [1] https://github.com/norvig/paip-lisp https://github.com/norvig/paip-lisp [2] PDFs can be found on Google Clojure is not recommended as it is very different to Lisp. Lisp code needs to be entirely rewritten before it will run on Clojure. That is not true for Common Lisp, Emacs Lisp and even Scheme.
- lerax 7y agoClojure is always the wrong option to get into the principles of Lisp. * Clojure utilizes non-standard Lisp syntax like []{}, weird function declaration and differ semantics of some forms (like cond usage, a powerful specie of switch-case of Lisp); * Clojure don't have cons pairs, neither car and cdr operators. Cons pairs are fundamental Data Structures to build compound data, very well explored in SICP and any LISP text book. * Clojure has the batteries of Java, so you will own a giant ecosystem to build complex software, but the evil parts of jvm will be inherited too. For the first contact with Lisp, this can be a unnecessary pain in the ass. I would recommend to start a LISP journey with Land of Lisp or Practical Common Lisp (PCL), both focused in Common Lisp. Land of Lisp has a lot of history about the beginning of Lisp and the author write the book in a fun way, lot of charges and xkcd-like humor. The book has a collection of game projects per chapter, one at time, teaching principles of the language. PCL it's very useful for understanding specific parts of the language, I used as complement when Land of Lisp was not sufficient (loop topic on PCL is very good).
- tosh 7y agoanother angle: while Clojure is a Lisp with its own distinct flavor it gives you … * a large community of practitioners and professionals (great for asking questions, finding collaborators, …) * easy access to libraries in the js/jvm/.net ecosystems * a style that relies more on data and transformations of data (illuminating simplicity) in any case: it is worth digging deeper, one thing that kept me away was not knowing where to start (analysis paralysis). in hindsight picking any Lisp would have been great (instead of postponing). Find a thread and start pulling :) Rich Hickey’s talks were a great entry point for me https://github.com/tallesl/Rich-Hickey-fanclub https://github.com/tallesl/Rich-Hickey-fanclub e.g. https://www.youtube.com/watch?v=rI8tNMsozo0 https://www.youtube.com/watch?v=rI8tNMsozo0 (the “Simplicity Matters” keynote at Rails Conf 2012) edit: Land of Lisp is a great book as well
- blackrock 7y agoI get that Lisp is popular because of its meta-programming abilities, ie its macro system. And the reasoning was that you didn’t have to wait for the language writers to implement the feature you wanted, since you could implement it yourself as a macro. But this presented other problems, namely that you might end up coding your libraries on an island, and no one else could understand your code. This is probably why Lisp is mostly more powerful when there is only one or a few programmers working on the code base. But with the increase in other programming languages, and the massive amounts of other libraries out there, then is this macro system really all that necessary anymore?
- slifin 7y agoClojure is a lisp that runs on top of Java, JavaScript and a couple of others and has access to all of those libraries via npm and maven Having more libraries than most languages doesn't nullify the use of macros, macros are usually discouraged in application code because they don't compose well, don't make a macro if a function will do However having macros meant that when go popularised CSP concurrency at the language level it meant we didn't need to change the language (for all variants of Clojure) it just meant we could make a library with macros to do CSP concurrency and it works on the browser on the server etc Completely opt in, well documented as a library and we didn't weigh down the language with this feature, if or when the next big concurrency thing comes along we won't be looking to deprecate go channels from the language Macros are incredibly powerful and you probably won't need them often but for those small cases of scratching a particular itch they're a get out of jail free card