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

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)
Newer Posts
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 -