If Lisp is so great

How come it isn't used outside of academia?

brb thinking of witty analogy

Because it doesn't have a huge corporation behind it.

Because it's not so great.
Inb4 "appeal to majority".

It is used outside the academia, you just haven't looked hard enough.

>>5
That's what she said.

>>3
what about ruby, python, perl who also don't have a huge corporation behind them?

>>7
Python does not have a huge corporation behind it? Go back to /g/.

>>8
>>7 has to go vent his uneducated bullshit on here, because as you know, that is what the stupid do.

>>1
things like:

(+ 2 3)
scare people

>>7
Has ruby been used in anything but rails?

>>9
I can't get no satisfaction.
I can't get no girl reaction.
LOL.

>>11
Yeah. LOL is about the extend of your limited mentality.

>>10
RPN calculators doesn't look any better or worse than this, but they achieved a quite good reputation.

>>12
LOL

>>13
Yup. You sound like some one tooth inbred hick. Now go run along and scrub another toilet.

>>14
Thank you sir!
http://bit.ly/zdVUtJ ^_^

>>9
the stupids come to /prog/?

people in industry don't care about which language is the most elegant or productive. They only care whether or not it is seeples.

How come it isn't used outside of academia?
It isn't used there either actually, since Python replaced Scheme (badly) for introduction courses, and the rest... research died off with AI funding. Its true main purpose now is for companies to recruit hipsters, to promote non-Lisp languages (``JavaScript is powerful since its kinda like Lisp!'', etc), to extend emacs, and to have something for /prog/ to talk about.

>>18
since Python replaced Scheme (badly) for introduction courses,
Yep. As a proof, http://www-inst.eecs.berkeley.edu/~cs61a/sp12/book/objects.html#implementing-classes-and-objects vs the original SICP gives a whole new meaning to the word ``sad''.

Scheme is still used in academia, the hot topics are continuations and hygienic macros.

>>19

def make_account_class():
        """Return the Account class, which has deposit and withdraw methods."""
        def __init__(self, account_holder):
            self['set']('holder', account_holder)
            self['set']('balance', 0)
        def deposit(self, amount):
            """Increase the account balance by amount and return the new balance."""
            new_balance = self['get']('balance') + amount
            self['set']('balance', new_balance)
            return self['get']('balance')
        def withdraw(self, amount):
            """Decrease the account balance by amount and return the new balance."""
            balance = self['get']('balance')
            if amount > balance:
                return 'Insufficient funds'
            self['set']('balance', balance - amount)
            return self['get']('balance')
        return make_class({'__init__': __init__,
                           'deposit':  deposit,
                           'withdraw': withdraw,
                           'interest': 0.02})
Beautiful!

(define (make-account balance)
  (define (withdraw amount)
    (if (>= balance amount)
        (begin (set! balance (- balance amount))
               balance)
        "Insufficient funds"))
  (define (deposit amount)
    (set! balance (+ balance amount))
    balance)
  (define (dispatch m)
    (cond ((eq? m 'withdraw) withdraw)
          ((eq? m 'deposit) deposit)
          (else (error "Unknown request -- MAKE-ACCOUNT"
                       m))))
  dispatch)

>>21
It's a lot better looking.
Compare:

        def deposit(self, amount):
            """Increase the account balance by amount and return the new balance."""
            new_balance = self['get']('balance') + amount
            self['set']('balance', new_balance)
            return self['get']('balance')
with
(define (deposit amount)
    (set! balance (+ balance amount))
    balance)

Why are they doing things from SICP in Python? It's an abomination.

>>19
call/cc is shit, shift/reset is king
hygienic macros are shit, gensym is king

>>19
>>20

                                                                                                                                                     
                                                                                                                                                     
                                               ..`++``                                                                                               
                                             `:hddddhhdd:                                                                                            
                                            :hddhhhhhhhhhy-                                                                                          
                                           sdddddhhhhhhhhhd/                                                                                         
                                          .dhmmdhhhhhhhhhhhd`                                                                                        
                                          +dddhhddddhddhhhhds                                                                                        
                                          /mhhhds++oyh+sdddhd-     ``                                                                                
                                          ymdhds-...--///yy/oyo+++oooo+/-`                                                                           
                                          hmmmm/....+yo-...++o+oo/////++oss+-`                                                                       
                                          .hmydd+/+ymdy-...oy/--y/////////+shho-                                                                     
                                           :o`/yydo+o+-....+yoooy///////////oymyo`                                                                   
                                              -ooh:.---:/+.oysydsss+/////+oyo++osy:                                                                  
                                          `   `ossssy+s+/o:hhhhyyydyo+/+syo:....:od/                                                                 
                                          `. ` /yyyohdNd+/hhyyyyyydmdyohso+:-.....:y+`                                                               
                                           ` :-:ossmmhyo+odhhyyyyyyyhdmdhsso+/--..../+-                                                              
                                          `./+++/ohy//syhhhhdo-:yhhdddhyyhhhyso+/:-...++`                                                            
                                        `/so/::+s++/++odoossy-  `/ohyyyyyyyyyhhhyso+:-.:+-                                                           
                                      .+soso:+o+::+-` .y+-+oy:     :yyyyyyyyyyyyhdmds+-..s-                                                          
                                    .oy+:o+:/oo+/+-..  oy.-oyo      hNmddhhhddmmNNmso:../+                                                           
                                 .. o::yo:-++/yho-+:   oy.-ooy    .+hyhddmhhmdhhhdoo:..//                                                            
                                `+-.o+ooh/:::/sy-     .sd.:ooh   +shyhhhddhddddhdso:..o:                                                             
                               `o-.oo/://:::/o+`       .o::ooh  .sodhhhhmhhNNmhdy+-.-yy                                                              
                                .+o//:://:/+y`          -+-oss `soyhhddddhdmmddh+-.:hh.                                                              
                               +o/://::os/++/.`          y.+s+ ooodhhhmdmmddyyh+-.+ss/                                                               
                              :s:--+:::+o/o: -           //:ssoyoyhhhhhdmhooo+-./yo+s                                 .://+y:                        
 :`       `                 -os+sh/:/s::/o+              `s.+o+shdhhhhhhdhs+/-/yhhsy.                              -/+/--ohys-                       
   +/     .: `             :/os///:::+//o/-`           /  /+-oohmmdhhhhhdssyhhhhhhh+                             .+:.-/shhy++y`                      
   /y+     ++s`    .+:   -/::-:oss+::::o/             `o`:/h:ossymmmhhhhdshdooooshh`                            os+//dyyyys++os`                     
   `s:-h/  :s+/    .+: `+o/:-:+oyyyo::++               `ysyhoydymhmhhho.sdhh++++od:                             -.`` /dyyy+++++o                     
    oosys+  +oy     `. .y+:-:o/+o:+/:/y`                ``yymhhdmhhhs-  +hhh++++oy                                    ohhs+++++s-                    
 `  .o///s:  `/-   .+--s/:--++::+:::ss:           +.     oy+oshhhhd:    ohyo++oyhd:                                   `hyo++ooosy-----------.`       
     //::/s/s/-`  `/. oo+s/--:::s+oys+``           `.--.oys+shhhhs.     hhy+++hmyooo`                                //+so+++//:/:::::::::::/:       
`. . ++/::/+/+y..  ` /+/+o:--:::/+o:` -+      `:+:/so+/ss++yhhhh/`     /hhysooyds++os-                        ..--..-y--.-:.-::/-::-:---:::-/:       
 ` y/:s:/::::/yyo ..++:o///++:::/s- -s.     `/oo++/-` :y+oyhhho.        -yhyhhyo++++oy/                     -+ydddhhho.../o-shoh-oyyhhsydoy:+-       
 -sshss::::::y+-.-so/::oo++oo:///y: :: `+-  ./o-``   :yoshhhy:           :dhhhhyo+++++y/                    o-hyhhmhd:...:o//+:o-+o//+///-+:o.       
`y+/+yo/+s/::oo +o++:-osh+o+:+yo+/`-` `++`.`.``/-.-/:yosdhho`             :shhhhho+++++y-                   o:dydmhhh..-..::::::::::::--:+/:y`       
`oo///o:+s/::/s::/oy:+y:/o+:::+o+/ys-/oso+os/``:++odyoydho-                 -ohhhhs++++oy`                  o-osyso+/:.:.o/oy+osyyssdshodys/y        
  -y/:/+::/:::/os+++oo:-/s+:/oo+osho+/////+- `/+:/sdydNd/                     .+yhdyo+++sy:o`               y-.-///+-y//-y+y+om+oyyhhsyshh+.y        
 ``+o:sso/://:://++++::::ooo+oh+oso////s+/+//+///smdmNNdo   `--                 `:ydhosyhyyo                h./+ooo:/do/.osyssdsosyosssssy-.y        
 /oos/+o//::yy/////:o:/oo::oooo+/+y/::/ys/////:.+NMMNMMN.  .os:                   `omdddhyss.`              h++++::/s/./..---/oos+y+ysyo:...y        
  `-os+::///y+::///o+/+s++s+/:+o//:::+/////+o///dmdMMMMN+-+/``  .                  `+ssmmmNNNh.            .yh+//+o/-../.....o+sdoosoooo-...y        
  -ooo+s+:://:s+//ohy///oo////os/::/://///////+/+oosmNh+osy+/:::o///:/::::::::::-::....mMMMMMMm-  ````./::/os+s+/-:.::--.....yoosho+doyy....y        
   .:ydo+/://////os/+so/////////+yo//////:::::+//ss//+///+soydhysyyyssys+yyhhssyyhh++odMMMMMMMNs./oyooh/+ssossys+/-/yo+o:...-oo/+++/oooo----y        
 `+ooshssssssosshysossysoossssssysossyso+///+oosoooosyyoooohyooooosy+sys//+so++++oo++NMMMMMMMNy-`/yoo/s++++oo+ssodyshssoooooooooooooooo+++++/        
.::---....-:/+yhsoyydmy:.+yso/``````.+oo::/++..+++:-++:`  `-::::--.``-. :://``+s+::/+mNmdhys+:` :o//://` `-   ``..../+-`-+.---.``                    
:/-    /oo+o//syy/o+//+y-.--..::`   .::-       .--.                 -/. `..   ``     `````   -/ ...--.`  `-/++++..oo-  /oossho/.                     
       -::::::/+//////:.     -/:`                                                                      .o+:.``         `:.`..                        
                                                                                                            .`

>>23
I wish I were simple minded like you are.

>>25
Not really. Fuck off and die, cock sucking pedantic piece of shit faggot.

>>26
True, I don't want to be a retard.

>>27
go back to y combinator you cock sucking faggot, enjoy spending the rest of your life working on a better "haskell typesystem"

>>1

However, Lisp is used outside academia. A better question is, why isn't it used much more than it is (inside or outside academia).

That is a legitimate question, and there are good answers (no single one of which is the right one).

Lisp hit a high level of maturity (accompanied by size) at a time when non-Lisp programming was being done with stone knives and bearskins.

I mean, can you imagine? Today's Common Lisp is pretty much the same as it was in 1982. Only the hardware was 1982 hardware.

Lisp peaked early, exactly when the hardware was barely able to to handle it. So there was a heydey when Lisp was used all over the place, but at the same time people were looking for ways to do the same stuff in a smaller footprint. (Example: the CLIPS expert system, a 1980's "Greenspun" rewrite of a Lisp-based system, to run on little PC's instead of big workstations.)

As soon as it became practical to run Lisp-like languages on cheaply available hardware, various people seized opportunities to go back, grab a handful of Lisp concepts and spin them into new languages, carefully avoiding the word Lisp and syntax which resembles it.

For instance, take Javascript. This is just Jamie Zawinski's Lisp in disguise. (If you don't speak Lisp, you can hardly understand that guy's blog 100%. It's in his vocabulary!)

I'm afraid that until the old management idiots from 1980's finally die off, they will continue to spread the idea that Lisp is "that resource hungry, big environment that takes over the whole machine" even though some implementations run in just a few megabytes, and machines with multi-gigabyte memories are available for a couple hundred bucks from consumer outlets.

Learning lisp will alter your life.

Your brain will grow bigger than you ever thought possible.

You will rewrite all of your applications in just a handful of lines

Society will shun you. You will shun society.

You will become disatisfied with everything and everyone around you.

Lisp is so simple to learn that you can learn lisp in just a few minutes. I just learnt it now while I was waiting for a bus.

Lisp is so simple that you can implement it in any language in just a few pages of code. This might never happen though, because once you've learnt lisp you'd never want to write anything in any language other than lisp, so you wouldn't bother implementing lisp in any language other than lisp.

Lisp can be fully implemented in lisp in just a handful of lines. I just implemented lisp in lisp, fully, while i was hopping onto a bus and paying for my bus ticket all at the same time.

When you become a lisper, you will laugh at jokes that no one else thinks are funny. You will know things that cannot be expressed in ordinary imperative language.

You will think people are idiots when they state things like "Hi, how are you?" because a lisper simply doesn't need to use such verbose constructs. Lisp abstracts away those patterns of interaction and makes them completely irrelevant. The proper way to greet a fellow lisper is just a tiny nod of the chin, and about a tenth of a wink from your left eye, then point at your tin foil hat. They will know what you mean. if they don't know what you mean then they are not a true lisp programmer and they don't matter anyway.

Lisp was invented a long time ago, before java, before C, before fortran, before computers, before people, before the earth was built. the universe itself is a lisp program so trivial that no true lisper would even both implementing it.

Lisp is so elegant that the very fact that you know even the first thing about it will qualify you for a season as principal dancer of the royal ballet. You will go out on stage in your little tutu and just scribble a few round brackets in the air with your toe. People will gasp in wonder. Unless they don't know any lisp. If they don't know any lisp then they are idiots and they don't matter.

Only lispers have a true definition of fun. Maybe ML programmers too. All of today's languages are based on fortran and lisp. The bad bits fortran, the good: lisp.

If you're good enough to use lisp, you'll soon be frustrated with lisp. Lisp is not an adequate lisp. By the time my bus had made it two blocks I'd written some simple lisp macros that were so powerful they made lisp completely obsolete and replaced it with a new language. Fortunately, that new language was also called lisp. And i was able to prove, mathematically, that the new lisp i'd created was both far superior to lisp in every conceivable way, but also exactly equivalent to lisp in every possible way. I was very excited by this. But also found it very boring.

Reddit is proof that lisp is really powerful. Paul Graham originally wrote reddit, in lisp, on the back of a napkin while he was waiting for a coffee. it was so powerful that it had to be rewritten in python just so that ordinary computers could understand it. Because it was written in lisp it was almost no effort to rewrite the entire thing, and the rewrite was completed in-between two processor cycles. Paul Graham himself was completely written in lisp, by an earlier version of himself, also written in lisp, by an earlier version of lisp. It's lisp, paul graham, lisp, paul graham, all the way down.

Because we've reached the limits of moore's law, the computers of the future will have many-core processors and all our programs will need to be written in a combination of haskell and lisp, that will itself be so powerful that the computers of the future will not be able to implement any of our ideas without creating time-travelling algorithms that borrow processing power from other computers that are further into the future. This sounds difficult, but in lisp it isn't difficult at all. in haskell this is a built-in feature and the way you implement it is just a no-brainer to any one who knows lisp or haskell.

After that, the computer of the future will be called The Lisputer. It's speed will be measured using the Lispunit, which is a measure of how many simultaneous arguments about the inadequacy of lisp can be proposed and defeated by an infinite number of lisp pundits without any actual decisions being made. Today's computers run at just under one lispunit. The Lisputer will run at lisp Lispunits, where lisp is a fundamental maximum constant of the universe that can't be expressed using ordinary imperative numerals. Suffice to say that it ends with an infinite number of closing parentheses.

java sucks.

    I think Java is the best language going today, which is to say, it's the marginally acceptable one among the set of complete bagbiting loser languages that we have to work with out here in the real world. Java is far, far more pleasant to work with than C or C++ or Perl or Tcl/Tk or even Emacs-Lisp. When I first started using Java, it felt like an old friend: like finally I was back using a real object system, before the blights of C (the PDP-11 assembler that thinks it's a language) and C++ (the PDP-11 assembler that thinks it's an object system) took over the world.

    However, as I settled in, I found a lot of things about Java that irritate me. As this happened, I wrote them down. The following document was mostly written while I was learning the language, during the design and development of Grendel back in 1997. Therefore, some of the following complaints might have been addressed in later versions of the language, or they might have been misunderstandings on my part.

>>31
http://www.jwz.org/doc/java.html

check 'em

>>30
disatisfied
huh

>>30
That was beautiful.

>>34

Taking the time to point out such a trivial typo makes YOU look like a retard, not >>30

At least LISP is used in academia to teach functional programming.
Haskell, not even.

On a side note, didn't Naughty Dog use their own custom LISP compiler for their videogames?

>>37
They still use Racket.

If Lisp is so great than why doesn't it even have a standard GUI

>>1
Lisp is great because a small number of loud people claim that it is great.

Follow the logic?