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

Pages: 1-4041-

If Lisp is so great

Name: Anonymous 2012-01-21 6:59

How come it isn't used outside of academia?

Name: Anonymous 2012-01-21 7:12

brb thinking of witty analogy

Name: Anonymous 2012-01-21 7:27

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

Name: Anonymous 2012-01-21 7:28

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

Name: Anonymous 2012-01-21 7:32

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

Name: Anonymous 2012-01-21 8:04

>>5
That's what she said.

Name: Anonymous 2012-01-21 11:50

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

Name: Anonymous 2012-01-21 11:51

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

Name: Anonymous 2012-01-21 11:52

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

Name: Anonymous 2012-01-21 11:59

>>1
things like:

(+ 2 3)

scare people

Name: Anonymous 2012-01-21 12:10

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

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

LOL.

Name: Anonymous 2012-01-21 12:11

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

Name: Anonymous 2012-01-21 12:24

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

>>12
LOL

Name: Anonymous 2012-01-21 12:26

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

Name: Anonymous 2012-01-21 12:39

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

Name: Anonymous 2012-01-21 14:27

>>9
the stupids come to /prog/?

Name: Anonymous 2012-01-21 14:34

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

Name: Anonymous 2012-01-21 14:41

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.

Name: Anonymous 2012-01-21 15:24

>>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.

Name: Anonymous 2012-01-21 16:45

>>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!

Name: Anonymous 2012-01-21 17:10

(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)

Name: Anonymous 2012-01-21 17:16

>>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.

Name: Anonymous 2012-01-21 17:16

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

Name: Anonymous 2012-01-21 17:26

>>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+:.``         `:.`..                        
                                                                                                            .`

Name: Anonymous 2012-01-21 17:27

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

Name: Anonymous 2012-01-21 17:31

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

Name: Anonymous 2012-01-21 17:42

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

Name: Anonymous 2012-01-21 17:44

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

Name: Anonymous 2012-01-21 20:44

>>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.

Name: Anonymous 2012-01-21 22:23

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.

Name: Jamie Zawinski 2012-01-21 22:48

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.

Name: Anonymous 2012-01-21 22:55

Name: Anonymous 2012-01-21 23:02

check 'em

Name: Anonymous 2012-01-22 0:41

>>30
disatisfied
huh

Name: Anonymous 2012-01-22 5:31

>>30
That was beautiful.

Name: Anonymous 2012-01-22 10:40

>>34

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

Name: Anonymous 2012-01-22 11:06

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?

Name: Anonymous 2012-01-22 11:10

>>37
They still use Racket.

Name: Anonymous 2012-01-22 11:35

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

Name: Anonymous 2012-01-22 14:06

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

Follow the logic?

Name: Anonymous 2012-01-22 14:17

>>37
ohhh lisper, always fighting other languages

Name: Anonymous 2012-01-22 14:20

>>30
this is what idiots actually belive!

Name: Anonymous 2012-01-22 15:03

>>30
Lots of Irritating Silly Parens

Name: Anonymous 2012-01-22 15:04

If Lisp is so great, how come it doesn't check my dubs for me?

Name: Anonymous 2012-01-22 15:19

>>39
It has multiple GUI APIs, some portable, some not so much. The ``standard'' GUI API tends to be CLIM which is codified in a standard of its own. If you want something more "modern", you can try Qt ports and similar stuff (also see some commercial implementations).

>>40-43
I don't care what you think or what other people think about the language. Either learn it or stop bitching about it you don't even know it. Lisp has got to be one of the more hated niche languages, yet almost all haters never even learned it, they tend to just get stuck on the syntax or some other trivial non-sense that no true scotsm programmer would ever get stuck on then go and write inflamatory posts all over the Internet/Usenet/... Now if I think harder, I do know one single ``hater'' that actually knows the language well, but the reason he hates it has nothing to do with the language and everything to do with the fact that his employeers don't want him to use Lisp, so he tries to hate it otherwise he'll have to hate his employeers and quit his high paying job.

Name: Anonymous 2012-01-22 15:42

>>45
lisp syntax is fucking shit

parens should burn in hell

Name: Anonymous 2012-01-22 16:32

>>44


(for-each (lambda (thread)
            (for-each (lambda (post)
                        (if (eq (mod (number post) 11) 0)
                          (reply :thread thread
                                 :name ""
                                 :email "sage"
                                 :text ">>%d nice dubz bro[i]![/i]")))
                      (post-list thread)))
          thread-list)

Name: Anonymous 2012-01-22 16:46

>>47
That only works if the post number is only two digits! I suggest you reread SICP and try again.

Name: Anonymous 2012-01-22 17:14

>>48

my goodness!


(defun repeated-digits-unit (digits)
  (if (eq digits 1)
    1
    (+ (expt (repeated-digits-unit (- digits 1)) 10) 1)))

(defun maximum-repeating-postfix-digits (num)
  (labels ((check-digits (digits)
             (cond ((eq digits 1) 1)
                   ((eq (mod (mod num (expt 10 digits))
                             (repeated-digits-unit digits))
                        0)
                    digits)
                   (t check-digits (- digits 1)))))
    (check-digits (ceiling (log 10 num)))))

(for-each (lambda (thread)
            (for-each (lambda (post)
                        (let* ((post-number (number post)))
                              ((arity (maximum-repeating-postfix-digits post-number)))
                             
                        (if (> arity 1)
                          (reply :thread thread
                                 :name ""
                                 :email "sage"
                                 :text (concat ">>"
                                               (string post-number)
                                               " "
                                               (cond ((eq? arity 2) "nice double bro[i]![/i]")
                                                     ((eq? arity 3) "whoa shit! trips! nice trips bro!")
                                                     ((eq? arity 4) "quads! fucken quads! screen cap this shit /b/ros!")
                                                     ((eq? arity 5) "Lok@demQUINTS! EPIC QUINTS BRO!")
                                                     ((eq? arity 6) "those are some sexy sextupples bro.")
                                                     (t "I don't even know the name for that many tuppels bro.")))))))
                      (post-list thread)))
          thread-list)

Name: Anonymous 2012-01-22 17:40

new and improved.


(define reversed-digit-stream (num base)
  (lambda ()
    (if (= num 0)
      #f
      (let ((value (mod num base)))
        (set! num (/ num base))
        value))))

(define (maximum-repeating-prefix-length stream)
  (letrec ((first-value (stream)))
          ((helper (lambda (count)
                     (if (eq? (stream) first-value)
                       (helper (+ count 1))
                       count)))))
    (if (eq? first-value #f)
      0
      (helper 1))))

(define (maximum-repeating-postfix-digits num base)
  (maximum-repeating-prefix-length (reversed-digit-stream num base)))

Name: Anonymous 2012-01-22 18:16

my clojure solution


(defn dubz? [d]
  (>=
    (count (filter
             (fn equal-parts? [n]
               (= 1 (count (distinct (partition n (str d))))))
             (rest
               ((fn factorize [n]
                 (map
                   #(/ n %)
                   (filter #(zero? (rem n %)) (range 1 (+ n 1)))))
               (count (str d))))))
    1))





(dubz? 1)
=> false

(dubz? 11)
=> true

(dubz? 123)
=> false

(dubz? 123123)
=> true

(dubz? 'dubzdubzdubz)
=> true

Name: Anonymous 2012-01-22 18:20

>>51

sorry i should have named it "tupz?" not "dubz?"

Name: Anonymous 2012-01-22 18:30

>>51

oh wow, I never thought about multi digit dubz.

Name: Anonymous 2012-01-22 18:37

>>55
nice dubs bro

Name: Anonymous 2012-01-22 18:38

>>51
Read the specs!

Name: Anonymous 2012-01-22 23:32

rewrote clojure code to use a "tupz" function that returns a key => value map of all tuples found that looks like amount => string


(defn tupz [d]
  (let [d (str d) l (count d)]
   (reduce (fn [tuples size]
     (if (= 1 (count (distinct (partition size d))))
         (assoc tuples (/ l size) (subs d 0 size))
         tuples))
     {}
     ((fn factorize [n]
       (filter #(zero? (rem n %)) (range 1 n)))
     l))))


this way, dubz can be a special case


(defn dubz? [n] (contains? (tupz n) 2))

(defn quadz? [n] (contains? (tupz n) 4))






(dubz? 123123)
=> true

(dubz? 123123123123)
=> true

(quadz? 123123)
=> false

(quadz? 123123123123)
=> true

(tupz 123123123123)
=> {2 "123123", 4 "123"}

Name: Anonymous 2012-01-22 23:37

#include <string.h>
int dubs(char *dubs) {
     size_t n = strlen(dubs);
     if (n < 2) return 0;
     if (dubs[n-1] == dubs[n-2]) return 1;
     return 0;
}

Name: Anonymous 2012-01-22 23:51

>>56

wow. that's mighty compact code there.

Name: Anonymous 2012-01-23 0:06

Returns number of equivalent trailing digits:
+/∧\⊖N[⍴N]⍷N←((⌈10⍟1+N)/10)⊤N←1123456777
Checks for dubs:
=/10 10⊤12344

Name: Anonymous 2012-01-23 0:57

>>3705555577
inb4 shitstorm

Name: Anonymous 2012-01-23 13:41

I fucking love Lisp. But until it gets more popular, Hello Haskell!

Name: Anonymous 2012-01-23 14:34

>>61
until it gets more popular
Do you really believe?

Name: Anonymous 2012-01-23 14:55

>>61
fuck you faggot storm

Name: Anonymous 2012-01-23 16:36

8^2 GET

Name: Anonymous 2012-01-23 16:40

Because the Sussman is a Jew. Lisp is full of Kabbalistic arcana.

Name: Anonymous 2012-01-23 16:41

DIB DAB DUBS

Name: Kaz 2012-01-23 21:05

>>66

That's nothing:

    $ clisp -q
    [1]> (gensym "check-my-dubs-biatchez->")
    #:|check-my-dubs-biatchez->12655|
    [2]>

Ooh yeah ...

Name: Anonymous 2012-01-23 21:36

>>69

Nice position there, you two.

Don't change these.
Name: Email:
Entire Thread Thread List