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

Pages: 1-4041-

Lisp is going to die

Name: Anonymous 2011-05-21 23:31

It's too good for its own good.
http://www.winestockwebdesign.com/Essays/Lisp_Curse.html

Name: Anonymous 2011-05-21 23:52

Go back to reddit.

Name: Anonymous 2011-05-21 23:53

More excuses.  “We can't ever finish a single project in LISP is because it's too easy.”  You guys are all talk.

Name: Anonymous 2011-05-21 23:59

A Slashdotter may object that Emacs is already quite capable and can do anything that any other development environment can do, only better.

Name: Anonymous 2011-05-22 8:32

LISP Is Suffocation in Parens

Name: Anonymous 2011-05-22 11:11

Computer Science is a BULLSHIT degree. Learn a manly trade, like ENGINEERING.

Name: Anonymous 2011-05-22 11:43

Funny, that there are a number of Lisp-bashing sites, created by java and python people. Even funnier, than these people are trying to convice themselves, that their mediocre languages and software are worth something and that "the best is the enemy of the good".

Mess with the best die like the rest.

Name: Anonymous 2011-05-22 12:08

>>3
This is why people invented Turing tarpits.

In fact, most Lisp programmers are too lazy to do anything at all. They don't even make very good firewood.

Name: Anonymous 2011-05-22 12:08

>>6
Harold Camping is a civil engineer.

Name: Anonymous 2011-05-22 12:11

>>9
I believe you mean [o][b][u]social[/b][/u][/o] engineer.

Name: Anonymous 2011-05-22 12:15

>>10
I believe you mean I believe you mean social engineer. engineer.

Name: Anonymous 2011-05-22 12:20

>>11

I believe you fail at BBCode, FAGGOT

Name: Anonymous 2011-05-22 12:24

>>12
It's a pretty leet thing when you don't even have to take the heat for correcting your own bbcode because someone else will come along and take it for you.

Fortunately, thread one is pretty good at explaining the nuances. Except they've probably changed by now.

How do you write such a shitty tag parser, anyway?

Name: Anonymous 2011-05-22 12:29

Don't worry. You're aFAGGOT too.

Name: Anonymous 2011-05-22 12:37

>>14
What, you can't use spaces inside [code] tags?

Name: Anonymous 2011-05-22 12:47

>>3
We can't ever finish a single project in LISP is because it's too easy.
I did a Warcraft 2 in two months, coding few hours every odd day, having zero gamedev experience, while also coping with a buggy and incomplete interpreter with no debugging support or unit tests.

Name: Anonymous 2011-05-22 13:03

Wrong, wrong, wrong!

The real reason Lithp never became popular is because Lithp is a write-only language.

Name: Anonymous 2011-05-22 13:17

>>17
Then why C/C++ became popular?

Name: Anonymous 2011-05-22 13:18

ENTERPRISE

Name: Anonymous 2011-05-22 13:36

>>18
See is a language that is so dumbed down, it doesn't matter that its syntax is unreadable trash.  You only need to memorize a couple of symbols.  There's just not much of a structure that needs to be expressed, so you don't need a clear syntax to make it readable.

Sepples is a write-only language but everyone mostly sticks to the same dumbed down elements from the see language.

Name: Anonymous 2011-05-22 13:47

>>16
Of course you did.

But you did it alone. That's the point of the OP.

Name: Anonymous 2011-05-22 13:50

>>20
cunter

Name: Anonymous 2011-05-22 13:51

>>21
How long and how hard would've it been if he wrote it in C++? A few hours every odd day, with zero gamedev experience, a buggy compiler and no debugger other than print?

Name: Anonymous 2011-05-22 14:16

>>23
The point is that if he was working on a project large enough that it DID require multiple programmers, like an entire OS, it would have never been finished. RTFA.

Name: Anonymous 2011-05-22 14:17

>>20
Please tell us about m_iCnt and m_pszBuf.

Name: Anonymous 2011-05-22 14:20

>>24
Main problem would have been outsourcing cheap Lisp-programmers. Other than that, Lisp has a well done package system, which are enough for projects of any size.

Name: Anonymous 2011-05-22 14:22

>>26
Also, Lisp favours functional programming style on a global level (while allowing imperative on a local level), which alone removes most of C++ and Java design bugs.

Name: Anonymous 2011-05-22 14:24

>>26-27

You're funny because you're ignoring TFA still. There's still a social problem caused by everyone preferring his or her favourite way of doing things.

Name: Anonymous 2011-05-22 14:30

>>25

(LABELS (({ (] &REST [)
           (APPLY ([ ]) [))
         ([ (>)
           (ELT (] NIL) >))
         (] (<)
           (DO-EXTERNAL-SYMBOLS (] :CL) (PUSH ] <))
           (SORT < 'STRING< ':KEY 'STRING))
         (} ({ + ^)
           ({ 816 1/5)
           ({ 688
              ({ 875
                 ({ 398
                    NIL
                    "~{~A~^
~}"
                    (] NIL))
                 {
                 (+ { +)))
           ({ 381)
           ^))
  (DO* (({ 5248 ({ 584 } 36063))
        ([ 874 ({ 395 { 6))
        (] 4 ({ 584 { 6))
        (} 3785580492276528215065056 ({ 395 } 36063)))
       ((} [ ] ({ 977 ])) ({ 902) ({ 381))))

I don't know about everyone else, but I find this code to be pretty obvious and readable.  The parentheses are like the stripes on a zebra.  Reading Lisp code is as easy as counting the zebras in a herd.

Name: Anonymous 2011-05-22 14:31

>>28
Just like C++. Only better.

Name: Anonymous 2011-05-22 14:32

>>29
Shit, you really suck at Lisp.

Name: Anonymous 2011-05-22 14:32

>>30
No. C++ is caused by everyone preferring or not preferring Bjarne Stroustrup's favourite way of doing things.

Name: Anonymous 2011-05-22 14:34

>>7
They're bashing Lisp for entirely the wrong reasons. Really, the only reason (which you have no way of working around from within the language) to fucking hate Lisp are all the fucking parens. All the other arguments against it are pure bullshit, since the core design is sane and shitty libraries can simply be rewritten. Okay, maybe there's a point about cons-based data structures not being well-adapted to today's ISAs, but it can be worked around easily via a proper compiler or JIT; or you know, by using (typed) vectors.

>>1
see what I just wrote above

Name: Anonymous 2011-05-22 14:42

>>7,33
You're completely off topic, both of you. :\ The OP is talking about Lisp programmers not standardizing because it's too easy to re-implement everything. As a result, large projects that require collaboration (such as a new LispM) are impossible. The fact that we're still stuck with Emacs and its original design is proof of this.

Name: Anonymous 2011-05-22 14:45

>>28
everyone preferring his or her favourite way of doing things.
In practice, there is only one way to do The Right Thing.

Consider http://www.azillionmonkeys.com/qed/random.html

Lisp's random function is free from all these deficiencies and, I hope, every lisper would agree that is The Right Thing to do.

Name: Anonymous 2011-05-22 14:55

>>34
As a result, large projects that require collaboration (such as a new LispM) are impossible. The fact that we're still stuck with Emacs and its original design is proof of this.
I think it's rather because most programmers just go "what's with all the God damned parens" and walk away, which leaves even fewer people to contribute to such a project. Like it or not, most people care about syntax.

Name: Anonymous 2011-05-22 15:05

>>36
You're a funny guy, but we're talking about the programmers who don't say that. This would make a lot more sense if you spent five minutes reading the article. It's even in nice big lettering.

Name: Anonymous 2011-05-22 15:08

>>37
I read the article, and I think it's quite off. The reason why shit doesn't get done in Lisp is because there aren't many enough programmers to do it, not because Lisp programmers are specifically egotistical.

Name: Anonymous 2011-05-22 15:11

>>35
There isn't always one right way to implement things. The paper provides extending Scheme to do OOP as an example: there are dozens of different OOP frameworks for Scheme, most of them incomplete because they were written for a specific purpose.

Name: Anonymous 2011-05-22 15:11

>>38
Well. Let's find out, then.

Name: Anonymous 2011-05-22 15:22

>>39
CLOS is The Right Thing in relation to OOP. Most Lispers just don't care about OOP or even hate it:
It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures. -- Alan Perlis
The purpose of OOP is to act as a "herding mechanism" that keeps mediocre programmers in mediocre organizations from "doing too much damage". This is at the expense of slowing down productive programmers who know how to use more powerful and more compact techniques. -- Paul Graham

Name: Anonymous 2011-05-22 15:25

>>41
There are also prototype based systems (without metaclasses), but they are just different.

Name: Anonymous 2011-05-22 15:26

>>41
I like prototypes and Smalltalk-like systems more. What about them?

Name: >>43 2011-05-22 15:31

Of course, I've got Prometheus and ClosureTalk, but it's a beginner's exercise to write its own message-passing OO system.

Name: Anonymous 2011-05-22 15:43

>>43
Support an existing implementation, you want to be a standard. Integrate it into some Lisp implementaion, make it look like it's default.

Name: Anonymous 2011-05-22 15:59

>>45
But I don't need them, and all the Scheme implementations out there already ship a de facto standard OOP system. Chicken has COOPS (CLOS-like), Guile has GOOPS (CLOS-like), Racket has its class system, etc. All of them have Prometheus (prototypes) in some third party library. I don't need one of them in the standard, that's not the point of Scheme. OOP is not even idiomatic Scheme, they are only nice to have in certain situations, with certain code that is handled better with OOP than FP.
The only thing I really want I saw and immediately want in the standard was foof-loop, the best general looping construct I've seen so far. It is clean, extensible, handles really well the general cases, and it's portable between R5RS-compliant implementations. And it will likely be in Big R7RS, so I have no regrets.

When you write idiomatic Lisp/Scheme code, reinventing the wheel, you probably end up with something similiar to something else, already implemented, and you just end using that instead. Meanwhile, you've learned something new by reimplementing it.

Name: Anonymous 2011-05-22 16:00

>>46
s/I really want//

Name: Anonymous 2011-05-22 16:19

>>46
But what happens when it's time to put it into play? No one can decide! Your post just listed a whole shitload of redundant projects; perfect proof of the original point. Lispers can't agree on anything.

Name: Anonymous 2011-05-22 16:25

>>46
But I don't need them
What do you need?

and all the Scheme implementations out there already ship a de facto standard OOP system. Chicken has COOPS (CLOS-like), Guile has GOOPS (CLOS-like), Racket has its class system, etc.
Try replacing them with a single unifying system. Like CFFI for CL.

Name: Anonymous 2011-05-22 16:27

>>46
certain code that is handled better with OOP than FP.
Can you provide an example, where OOP is better than FP?

Name: Anonymous 2011-05-22 16:29

>>50
Interoperability between programs.

Name: Anonymous 2011-05-22 16:32

>>48
The world is made of people with different opinions on everything. Wars happen, but we still manage to survive somehow. It's the survival of the fittest, in the end there will be one or zero predominant OOP system for Scheme (just like with CL and CLOS), depending on the needs and preferences of most of the Schemers. And, just like I said before, most implementations have their de facto standard OOP system: you can't write real world Racket code using its GUI library disregarding its class system, since it is built on top of it. But you don't have to use it everyday for everything, no one forces it down your throat, you can use whatever approach you feel will better solve your problem.

Name: Anonymous 2011-05-22 16:33

>>50
Go fuck yourself.
>>51
You too.

Name: Anonymous 2011-05-22 16:33

>>51
Use packages.

Name: Anonymous 2011-05-22 16:43

>>52
OOP system: you can't write real world Racket code using its GUI library disregarding its class system, since it is built on top of it.
You can have a GUI framework without OOP. HTML, you're viewing now, is an example of such GUI.

Name: Anonymous 2011-05-22 16:45

news flash: /prog/ lisp advocates are just as stupid as everyone else

Name: Anonymous 2011-05-22 16:49

>>55
You're either retarded or you can't comprehend English.

Name: Anonymous 2011-05-22 16:52

>>57
It would be a great accomplishment of artificial intelligence programming if it were possible to form a sentence like "You can have a GUI framework without OOP" and not know what it means.

I'll go with "Retarded" for $500, Alex.

Name: Anonymous 2011-05-22 17:00

>>58
You still can't read, I was talking of Racket's class system and Racket's GUI framework, which (Racket's GUI framework) is written with its (Racket's) class system, is my English ambiguous or something? Where did I say ``they can only be written with OOP''?

I'll go with "Retarded" for $500, Alex.
That's not my name, but I'm glad you're accepting reality.

Name: VIPPER 2011-05-22 17:06

>>59
That's not my name,
Then why did you respond to him?

Name: Anonymous 2011-05-22 17:11

>>57
Nope. The problem is in you: stop complaining and write a GUI library without OOP. Nothing stops you.

Name: Anonymous 2011-05-22 17:14

>>61
>>59

Name: Anonymous 2011-05-22 17:20

>>62

Oh, ok.

Name: Anonymous 2011-05-22 17:21

>>63
>>203

Name: Anonymous 2011-05-22 23:33

I'm not going to bother reading it. Nothing is dead as long as it's developed. Any Lisp worth its salt is being actively maintained, and as long as people care about it, something of this sort cannot die.

Name: Anonymous 2011-05-23 10:59

>>6
I guess I'll switch my major from CS to Engineering. ;_;

Name: Anonymous 2011-05-23 11:17

>>65
The article wasn't about dying, that's a trollish distortion by the OP. It was about Lisp being stuck because of the lack of cooperation. Jeez, you guys.

Name: >>65 2011-05-23 13:37

>>67
I read it now. I can say I mostly agree with what the author has to say, but there is a solution to this. It's called writing a standard document and implementing it. This is how you have many standard-compliant Common Lisp implementation, a lot of R5RS and quite a few R6RS compatible Schemes. From those CL implementations, most have their MOP support (which is again defined in a standard) and gray streams (which is defined in a separate standard). As long as you're willing to define a well-thought-out interface, people will implement it (however, having a refrence implementation would be very nice as well).

Name: Anonymous 2011-05-23 15:11

>>68
Absolutely—but watch this video, especially the ending: http://www.youtube.com/watch?v=pQHX-SjgQvQ

How are you going to get people together to write the standard document? How are you going to get them to agree? That's the problem!

Name: Anonymous 2011-05-23 15:30

>>69
They someone managed to do it for ANSI CL, MOP, Gray Streams, CLIM, way too many to count LispM documents, R*RS Schemes, Scheme's countless SRFIs and various others. If anything, a single person can suffice, but it's been shown that community-driven processes also work, they just take much longer.
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 -