Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon.

Pages: 1-4041-

Spoiler: LISP is useless

Name: Anonymous 2009-10-28 21:29

Name one noteworthy program that was coded in LISP.

I'll wait.

Name: Anonymous 2009-10-28 21:29

Google.
That's right, Google was written in Lisp.
Just goes to show what you know.

Name: Anonymous 2009-10-28 21:31

Lisp is just slightly less useless than any other programming language.

Name: Anonymous 2009-10-28 21:31

scheme

Name: Anonymous 2009-10-28 21:32

>>4
i lol'd

Name: Anonymous 2009-10-28 21:42

Yahoo stores

Name: Anonymous 2009-10-28 21:45

>>6
Enterprise quality spam filters.

Name: Anonymous 2009-10-28 21:48

>>7
Yahoo quality spam filters.
*snicker*

Name: Anonymous 2009-10-28 22:01

Maxima

Name: Anonymous 2009-10-28 22:06

That airline booking thing that I can never remember the name of, is written in Lisp. I've also heard that Anonix 2.0 will be written in Lisp

Name: Anonymous 2009-10-28 22:19

Also most Lisp implementations are written in Lisp.

Name: Anonymous 2009-10-28 23:30

Plenty of nice in-house software is written in Lisp, for example stuff like EDA design tools.

Name: Anonymous 2009-10-29 0:28

>>2
Google was in python, as with youtube. Sorry.

Name: Anonymous 2009-10-29 1:23

>>13
Technically... Google is Python and Java; Youtube is Python and PHP. (What a fucking couple of hellish combinations.)

Name: Anonymous 2009-10-29 1:33

>>6

Spoiler: some parts of that were written initially in Lisp, and then later it was reimplemented in Java.

Name: Anonymous 2009-10-29 2:33

>>15
We are all intimately aware of PG's history and personal life, and therefore I saw fit to neglect certain details

Name: Anonymous 2009-10-29 3:06

>>1
http://franz.com/success/

Go to town.

Name: Anonymous 2009-10-29 3:15

>>17
http://franz.com/success/customer_apps/animation_graphics/naughtydog.lhtml

That's why Sony won last generation. Because they used Lisp!

Name: Anonymous 2009-10-29 3:30

While I've seen various success stories about Lisp floating around the internet, each time someone comes and asks about this, I find it stupid. Someone should judge a language by the actual qualities of the language, not by how popular or by how many commercial successes there have been using it. What are you? A manager? Just learn and use the damn language and find out what it can do for you, instead of wasting time reading stories off the internet.

Name: Anonymous 2009-10-29 3:34

As a small continuation to my last post. I've just written a program in about 10 minutes, worth about 25 lines of code, while last time I implemented something like that I used C for it and it took some 4 hours and some 350 lines of code. I find that enough reason to use it for my projects that aren't terribly low-level.

Name: Anonymous 2009-10-29 3:59

>>20
As a small continuation to my last post. I just re-wrote that Lisp program in Perl in under 2 minutes.

Name: Haxus the Skeptic 2009-10-29 4:46

>>20
Well tell us about the program and show us the code.

Name: Anonymous 2009-10-29 4:46

>>21
As a small continuation to my last post, I looked again at that Perl code and now my eyes bleed.

Name: Anonymous 2009-10-29 6:14

>>22
The program made use of CL's extensive list functions, such as: MAPLIST PUSH CONS FIRST/REST/CAR/CDR/CDAR SORT SET-DIFFERENCE REMOVE NREVERSE and some others, to implement a simple grpah manipulation algorithm. The C version had done the same things, but in an ad-hoc manner, leading to a lot of code duplication. I'm sure I could have factored away most of the similar code patterns, had I known Lisp before I wrote the C version, but alas that was a long time ago. Here's a sample of one of the functions used by it:


(defun seq (n m)
  (loop for i from n to m collect i))

(defun compute-graph
    (removal-order &optional (n (+ 2 (length removal-order))))
  (let ((vertex-bag (seq 1 n))
        edges)                
    (maplist #'(lambda (order)                                 
                 (push
                  (cons                      
                   (let ((next-vertex
                          (first (sort (set-difference vertex-bag order) #'<))))
                     (setf vertex-bag (remove next-vertex vertex-bag))
                     next-vertex)                          
                   (first order))
                  edges))
             removal-order)
    (let ((last-vertex (cdar edges)))
      (push (cons (car (remove last-vertex vertex-bag))
                  last-vertex) edges))
    (nreverse edges)))

The C program did something similar among other things it did, but it wasn't solving the same thing as this Lisp one, however it was similar.

Name: Anonymous 2009-10-29 8:25

Metacircular evalutation means you can have LISP in LISP. LISP is both every program and no program at all. That is noteworthy.

Name: Anonymous 2009-10-29 8:38

eval evaluation means you can have Perl in Perl. Perl is both every program and no program at all. That is noteworthy.

Name: Anonymous 2009-10-29 9:10

exec execution means you can have C in C. C is both every program and no program at all. That is noteworthy.

Name: Anonymous 2009-10-29 9:21

[code]sex[code] means you can have human in human. Human is both every being and no being at all. That is noteworthy.

Name: Haxus the BBCoder 2009-10-29 9:31

BBCode means you can have BBCodes in BBCodes.  BBCode is both every tag and no tag at all.  That is noteworthy.

Name: Anonymous 2009-10-29 10:35

Half of emacs.
The rest is the elisp interpreter, I suppose.

Name: Anonymous 2009-10-29 11:17

>>15
Spoiler: some parts of that were written initially in Lisp, and then later it was reimplemented in Java.
Is this really true?  When I posted it to /prog/ (the rewritten in Java part) I just made it up.

Name: Anonymous 2009-10-29 11:53

>>31
Shhhhhhh!

Name: Anonymous 2009-10-29 12:09

>>31
It's part true. They supposedly attempted to reimplement the fine Lisp code using SEPPLES for a while and had trouble, and they eventually ended up reimplementing a Lisp interpreter in SEPPLES. Greenspun's 10th rule and all.

You can't really blame big businesses for doing this, as they just wanted their software written in a language for which they think they could get replaceable programmerscogs easily.

Name: Anonymous 2009-10-29 12:19

>>1 Common Lisp implementations are written in Lisp. As is Macsyma, Maxima, the whole Symbolics Genera operating system, as well as some of Lenat's AIs.

Name: Anonymous 2009-10-29 12:23

>>33
IMO, you can blame them for it.

Name: Anonymous 2009-10-29 15:47

>>24

import List

computeGraph removalOrder Nothing  = computeGraph removalOrder (Just (length removalOrder + 2))
computeGraph removalOrder (Just n) = zip (init edgeStarts ++ [lastVertex]) (removalOrder ++ [last edgeStarts])
   where
      ((lastVertex:_), edgeStarts) = mapAccumL accumStep [1..n] $ tails removalOrder
      accumStep vertices order = (vertices \\ [edgeStart], edgeStart)
         where
            edgeStart = head $ vertices \\ order

Name: Anonymous 2009-10-29 16:07

>>36

[/code]import List
import Control.Monad.Instances

computeGraph removalOrder Nothing  = computeGraph removalOrder (Just (length removalOrder + 2))
computeGraph removalOrder (Just n) = zip (init edgeStarts ++ [lastVertex]) (removalOrder ++ [last edgeStarts])
   where
      ((lastVertex:_), edgeStarts) = mapAccumL accumStep [1..n] (tails removalOrder)
      accumStep vertices order = ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order)[/code]

Name: Anonymous 2009-10-29 16:09

FFFFFFF...

import List
import Control.Monad.Instances

computeGraph removalOrder Nothing  = computeGraph removalOrder (Just (length removalOrder + 2))
computeGraph removalOrder (Just n) = zip (init edgeStarts ++ [lastVertex]) (removalOrder ++ [last edgeStarts])
   where
      ((lastVertex:_), edgeStarts) = mapAccumL accumStep [1..n] (tails removalOrder)
      accumStep vertices order = ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order)

Name: Anonymous 2009-10-30 8:46

Did a bit of refactoring over the last version, looks a bit better to me, but it's hard to get it reach the Haskell version's terseness without defining a specific DSL.


(defun seq (n m)
  (loop for i from n to m collect i))

(defun singlep (list)
  (and (consp list) (null (cdr list))))

(defun compute-graph
    (removal-order &optional (n (+ 2 (length removal-order))))
  (let ((vertex-bag (seq 1 n)))    
    (mapcon #'(lambda (order)
                (labels ((get-next-edge (to)
                           (cons
                            (let ((next-vertex
                                   (first (sort (set-difference vertex-bag order) #'<))))
                              (setf vertex-bag (remove next-vertex vertex-bag))
                              next-vertex)
                            to)))
                  (let ((before-last-vertex (first order)))
                    (if (singlep order)                       
                        (list #1=(get-next-edge before-last-vertex) #1#)
                        (list #1#)))))
            removal-order)))

Name: Anonymous 2009-10-30 10:27

>>39

import List
import Control.Monad.Instances

computeGraph removalOrder = zip (init edgeStarts ++ [lastVertex]) (removalOrder ++ [last edgeStarts])
   where
      ((lastVertex:_), edgeStarts) = mapAccumL accumStep [1..maximum removalOrder + 2] (tails removalOrder)
      accumStep vertices order = ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order)

Name: Anonymous 2009-10-30 10:48


(defun compute-graph
    (removal-order &optional (n (+ 2 (length removal-order))))
  (let ((vertex-bag (seq 1 n)))    
    (mapcon #'(lambda (order)
          (labels ((get-next-edge ()
                 (cons
                  (let ((next-vertex
                     (first (sort (set-difference vertex-bag order) #'<))))
                (setf vertex-bag (remove next-vertex vertex-bag))
                next-vertex)
                  (first order))))
            (if (singlep order)           
            (list #1=(get-next-edge) #1#)
            (list #1#))))
        removal-order)))
Slightly shorter.

Name: Anonymous 2009-10-30 10:50


(defun compute-graph
    (removal-order &optional (n (+ 2 (length removal-order))))
  (let ((vertex-bag (seq 1 n)))    
    (mapcon #'(lambda (order)
                  (labels ((get-next-edge ()
                             (cons
                              (let ((next-vertex
                                     (first (sort (set-difference vertex-bag order) #'<))))
                                (setf vertex-bag (remove next-vertex vertex-bag))
                                next-vertex)
                              (first order))))
                    (if (singlep order)                       
                        (list #1=(get-next-edge) #1#)
                        (list #1#))))
            removal-order)))
Slightly shorter.
Reposted due to bad indentation/tabs from last post.

Name: Anonymous 2009-10-30 14:50

A more readable version, as a token of good faith.

computeGraph removalOrder =
   zip (init edgeStarts ++ [lastVertex]) (removalOrder ++ [last edgeStarts])
   where
      vertices = [1..maximum removalOrder + 2]
      ((lastVertex:_), edgeStarts) = mapAccumL getStart vertices (tails removalOrder)
      getStart vertices order = ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order)

Name: Anonymous 2009-10-30 15:19

>>40
Why not just use Perl?
Seriously.

Name: Anonymous 2009-10-30 15:26

>>44
I know you're likely trolling, but I'm actually curious if anyone could make a shorter version in some language other than Lisp or Haskell. I can read both versions just fine, but I can't think of shorter solutions.

Name: Anonymous 2009-10-30 15:32

>>44
Come on, now, the only part that you can really call perlish is ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order) , because of the pointlessness and such. The rest is pretty straight forward.

Name: Anonymous 2009-10-30 15:39

Someone write a Java version so we can all laugh at it.

Name: Anonymous 2009-10-31 0:06

>>43
[u]VALID PERL CODE[u]

Name: Anonymous 2009-10-31 0:18

>>48
Invalid BBCODE

Name: Anonymous 2009-10-31 9:13

Here's an even more readable version, as a token of nothing better to do.

import List
import Control.Monad.Instances

computeGraph removalOrder = edges
   where
      { ((lastVertex:_), edgeStarts) = mapAccumL getStart vertices (tails removalOrder)
      ;      getStart vertices order = ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order)
      ;                     vertices = [1..maximum removalOrder + 2]
      ;                        edges = zip (init edgeStarts ++ [lastVertex]) (removalOrder ++ [last edgeStarts]) }

Name: Anonymous 2009-10-31 17:23

Yet another one, as a token of masturbation.

import List
import Control.Monad.Instances

computeGraph removalOrder = edges
   where
      { ((lastVertex:_), edgeStarts) = mapAccumL getStart vertices (tails removalOrder)
      ;      getStart vertices order = ((,) =<< (vertices \\) . (:[])) $ head (vertices \\ order)
      ;                     vertices = [1..maximum removalOrder + 2]
      ;                        edges = zip (init edgeStarts ++ [lastVertex])
                                           (removalOrder    ++ [last edgeStarts]) }

Name: Anonymous 2009-10-31 18:35

Please refrain from posting non-programming related material.

Thank you.

Name: Anonymous 2009-10-31 21:56

>>52
OK.

Name: Anonymous 2009-11-01 1:42

>>53
non-programming related material detected

Name: Anonymous 2009-11-01 8:08

>>51
Now replace all the names with single characters (+Points for non-ASCII).

Name: Anonymous 2009-11-01 9:05

>>55
and you have APL/J/PEARL

Name: Anonymous 2009-11-01 9:39

Lispers are conceited morons.
Exhibit 1: http://en.wikipedia.org/wiki/Greenspun%27s_Tenth_Rule
Only a Lisper would come up with this kind of blatantly retarded and incorrect "rule" and try to pass it off as fact.
They're just monkeys masturbating over their bloated, ancient, steaming pile of shit language.
Worst programmers in the world.

Name: Anonymous 2009-11-01 9:44

>>57
You sound butthurt.

Name: Anonymous 2009-11-01 9:45

>>57
you have not achieved satori

Name: Anonymous 2009-11-01 9:49

>>58,59
yeah yeah yeah.
enjoy your 1GB helloworld program

Name: Anonymous 2009-11-01 12:02

>>60
I lol'd, If you're going to misrepresent the facts at least do it half as well as the troll in the thread we had on this

Name: Anonymous 2009-11-01 12:05

>>55
Why would I do that?

Name: Anonymous 2010-12-17 1:32

Are you GAY?
Are you a NIGGER?
Are you a GAY NIGGER?

If you answered "Yes" to all of the above questions, then GNAA (GAY NIGGER ASSOCIATION OF AMERICA) might be exactly what you've been looking for!

Name: 2013-01-25 18:19

㌸ࠖ♀⅔坸䅁࢕╨ሴ吸陖㠔螗␡鐠莙耀䙈挃р琈怱眲䌐䕴癐ㄇ㑵獒椴蕗礈ᆁ鍦で̩褣ࢅ甶⁕㝸え隈愑⥲㈴酦嘐ㄱ䅠ᅉ匓㙰獅夲ሓ霷瘲✂䍘ᑩ。㙵醙啈摧ㄡ捣ኆ錄蝔⎇ф睴べㄶ劁࠰陆餴阅⒆猃瑑锴䅲萄儴䖙虩䌃咆こ遇吉妅嚇ܗƒ鍳ͱ皃灣兒灶䝒҅䐰͠榒䤲芁Ʌℶ㚘ᅉ覄怀靵ऴ〔慨垔䆓鑷憂唃ԓ牘ሐ怙聴ᒔ癶甦怶‥䑗光匓ԩ䥑₁鄥袓㜹茸⡔㉖䕴祷萂蒉馅䈡䁖票ᘣŰㄨ獦ᦄ瑂ᙡ䝅鄠憈煔অ⡱❤肄舘督⍕昷ፆ͓鄶㡨堡ᡃ啢⤶ᑙᐸ4䤰嘂儘瑑堙㜶ኀ挱䁒✆☩蜶卹栤剳㤩呥Ԉ憗̉腕撂圦偈蔓␓ሁ攦攡‑戈镗ᅤ镗㠸ሠд䠗坔適㍅⤸靠㉁㥔噉䜦䔢舤衁䀄䦄䌲㍄呕㑰撓ࡠᑘ癃⡵㔱䠆扵腀ࠓ晈焗䤣䎑憆脘㔶℉☩蚃爇ሩ䒂㚑㤡"⑙愕▆⥓✅ₘ顇䁶ّ݆戨⑴嘦覈㙗瑢饅匃儈䥒镐遡砖南ጴ䙈ᡡ捙᎙⊐奵葆Ԁ⍁愄挹唒逩呃剖Ű呢ڕ锨煃灘☷艕܈选攁ጷ饥䜁芕朠ᤳ␙⍰ℐ瞒␢ゕ㜀鑇⢆猆☹隑㥑圣妙䜑蕗阥Ɉ昵堲甉傆圣袄➔鎄㥔Ф煐㜢儢啅㔓ᤆ爣؉䈡煂鑃硸䑀䄦䌃阃Ⅲ⑱撗঄畨夑虩祈襥甐ၴى鎁ࡷ恃瀴掄枉❱捕㔢䢈憀∀ıቲ঄怱掉ℴ杴犄抆ᝈ䞕鍐ɱ萕䑶⠀薂癶╱㍁蘉㜩脄≘╠ᑴᥨɂ䌒١興ࠄ⤓šб灒肃塒眓㕅ݤ隒瑸镴С蠆焙Ѓ閃楘嚄፠ᠲ၈排榃咕夈划╨挵餧䑷倵偶剠鐄兂ቘ晶概䒇ȗ猠癳ɸ劓暀刐␦閄栘⅐ባ㎀嚔ᤅ啖⡆焵塔頸⤁鍢䘈䜹ⅇ╅噠猙瀴耳吓艱按

Name: Anonymous 2013-01-25 18:30

What about emacs? Yes, initially it was written in C, but now it is more than 80% Emacs Lisp

Name: Anonymous 2013-01-25 20:08

>>1
Name one noteworthy program that was coded in LISP.
Symta.

http://sym.at.ua/load

Name: Anonymous 2013-01-25 20:25

>>66
nice dubz

Name: Anonymous 2013-01-25 21:48

http://sym.at.ua/load/wc2mapgen/1-1-0-10#comments
1 Rabbi Chaim Herbwinski   (09.12.2012 06:57)
Shalom!
Which one of you niggers did this?

Name: Hartley Hare 2013-01-25 22:54

>>68
It wasn't me, it was Michael.

Name: Anonymous 2013-01-25 23:44

>>9
this is infact, the only lisp program i use

Name: Anonymous 2013-01-25 23:47

>>38
beautiful

Name: Anonymous 2013-01-25 23:49

>>57
the rule also includes the implementation of CL as an victim

Name: Anonymous 2013-01-26 2:15

>>68
I tried to upboat it but I guess you have to be registered

Name: Anonymous 2013-01-26 2:15

>>63
the Peak of N. american culture!
xD

Name: Anonymous 2013-01-26 2:21

>>74
Three words for you... Oprah
xDD

Name: Anonymous 2013-01-26 2:47

& 2nd place goes to... Ellen!
tied 3rd place being all the rich-scabs American Pickers! // Cash Cowboys! // Hardcore Pawn // Insert Generic-Rich-Scab-tv-knock-off here..
(Yeah, kind of scraping the bottom of the barrel already....) xD It's a big-arsed empty barrel....

Name: Anonymous 2013-01-26 3:13

Sorry, but i too 'have' to put up with this miserable shiich on telly and i'm on the continent opposite (antipodally)... fuck sake bring back the test pattern xD it's less bloody ignorant..
btw i weigh 11 stone... i notice you don't even use stone, why is that? pounds sound lighter? ~71,000 grams and steady yip-yip i'm light as fook ^^

Name: Anonymous 2013-01-26 3:18

71,000 feathers, or 156.5 tubs of lard xD

Name: Anonymous 2013-01-26 4:00

>>77 consider suicide

Name: Anonymous 2013-01-26 7:47

>>79 nah, that line of reasoning is defunct.. i have a pc =) i can make my own test-pattern.. ^^
i figured it out anyway, it's too much effort to convert pounds to stone without a calculator xD 14pound/stone or somethin?
Don't change these.
Name: Email:
Entire Thread Thread List
All trademarks and copyrights on this site are owned by their respective parties. All comments and posts are the responsibility of their own posters.
- Tinychan + 2ch Mode -