Install X/Y

Why do you think this is so funny?

Do you think it's funny cause it's a play on an (as apparent to you) nonsensical phrase GNU/Linux?

Do you think it's funny because BSD and Gentoo aren't very popular, and require a lot of effort to maintain, so you think programmers use it cause programmers like things like this?

I am an expert programmer, and a Lisp wizard. I do not particularly care about UNIX politics, and view all current operating systems as retarded. However, I do like the GNU approach to UNIX (although not necessarily the reality) the most out of all the other approaches from a technical stand point.

Maybe you think installing these operating systems is a difficult act that only strange programmers would participate in.

I do not understand why you think ``install BSD/Gentoo'' is so amusing. Why do you place it everywhere?

>>39
You have Common Lisp. CCL, SBCL and both ENTERPRISE implementations compile to native, can inline assembler etc. etc. You can use CFFI for addressing if that's all you need.

>>41
Common Lisp doesn't scale and has no notion of processes or security.

>>42
Yep. Surprising how a statically-typed language can have NO type safety and thus no modularity and thus no scalability.

>>34
Is it possible to define a type-parameterized module or class in Common Lisp? What is the Common Lisp analogue of ML functors? Is there something like C++ templates, at least?

HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING
HASKELL IS KING

H E S S
E  E
S    S
S      S

>>45
Haskell is a language for solving problems imposed by the language.

>>42
All Common Lisp implementations feature threads or processes or something like this. The library Bordeaux threads can be used to provide a consistent interface across implementations.

>>43
Some implementations (notably CMUCL and SBCL) offer plenty of type saftey. Just declare types.

>>44
Well, if you just want something to be type generic then that's already taken care of because the language is dynamically types e.g. it doesn't matter if your list has cows or vertices or medical records in it, or a combination of these sort will still sort it. If, on the other hand, you want to restrict instances of some collection or object or whatever to some particular type and have that enforced, then one clever library I know of that extends Common Lisp in this direction is LIL (Lisp Interface Library).

You mention templates. Templates can be used to write type generic programs, but they can be used for much more than that. I would know, because I am an ENTERPRISE SEPPLES DEVELOPER. Of course, Lisp macros are like templates, just less retarded.

>>30
Some Lisp Machines:

FACOM Alpha
http://tinyurl.com/ka8sjf8

France Telecom's Maia
http://tinyurl.com/mtf4jg3

Thinking Machine Inc's CM5
http://tinyurl.com/q43cwh6

NEC Lime (joint venture with JAL)
http://tinyurl.com/mu6ewme

NTT Elis
http://tinyurl.com/meonphf

Xerox 6085
http://tinyurl.com/k3gnomw

TI Explorer
http://tinyurl.com/ktlfbzq

LMI Lambda
http://tinyurl.com/kt6suyq

The Symbolics 3600 family
http://tinyurl.com/lhplb76

50 CENT GET

>>49
CM5 has some cool design. And I love the idea of visualizing general machine state with leds.

>>51
sauce?

and a Lisp wizard
Comment disregarded.

>>48
No, type safety is not about just having more than one type. Type safety follows from the principle of substitution - the type of a closed expression must be indifferent to picking a subexpression and substituting another expression of the same type in its place. But in Common Lisp the substitution principle doesn't hold because of macros. For one thing, what is the type of a macro expression? It doesn't have a type in the general case - it could expand to whatever the hell it wants to.
Secondly, with macros operating on symbols and turning them into arbitrary symbols you cannot be sure what a different subexpression will be turned to by an enclosing macro - what if that macro hunts for the string "pajamas" and replaces it with a 0.0, and the subexpression was a function that returned the string "pajamas"? Then the functions return type was a string in the module it was defined in, but will become a flonum after you substitute it in.
Thus, Common Lisp has no type safety and therefore no modularity. And the package system is just namespaces, which is just pathetic for programming in the large - modularity cannot be based just on the way symbols are names, it must at least be based on their types so you don't try to import apples in place of oranges.

>>54
type safety
Stopped reading right there.

>>55
Just as expected. "Lisp wizards" are all stuck at the kindergarten level of unityped lambda-calculus. Go conjure some spirits with your wonderful macros.

>>54
OK.

Well, the substitution principle holds for the Lisp forms after macro expansion, but you're right that it doesn't necessarily hold for Lisp forms before macro expansion, and certainly not for the program text (the reader can do its own transformations).

Your 0.0 vs ``pajamas'' example is not very good.

First a macro enclosing a function call can't change the statically asserted return type of a function. That's not possible.

Secondly a macro within the body of a function with a statically asserted return type will signal an error on compile
if it expands to something that causes the function to return anything other than the statically asserted type.

The package system works very well.

>>56
The lambda calculus is not Lisp. One is a formal logic, the other is a programming language.

Same applies for typed lambda calculus (or categories or whatever) and your favorite ML derivative (I am almost certain you are a Haskell programmer, because only Haskell programmers exhibit the kind of strong combination of ignorance and arrogance you do).


this thread is                                                                        '
>THE TOP KEKEST

this thread is                                                                        '
>THE TOP KEKEST

this thread is                                                                        '
>THE TOP KEKEST

this thread is                                                                        '
>THE TOP KEKEST

>>56
I'm not going to post here anymore.

You will probably reply with some more incorrect statemens, that will make me want to post some more.

However, I'll try my hardest to refrain. Please, instead of slandering Lisp, use Lisp. See what its like to write real programs in it. Then say if you hate it or not.

Don't learn Lisp.

Whatever you do just don't. You will be unhappy forever.

Just stick with Haskell or C# or Scala or whatever. Don't do what I have done.

>>61
Explain

>>58
More hair-splitting, please. It's very relevant and helps uncover genuine useful facts. Yes, I'm good enough to learn and use Haskell, at least a moderate level - you're probably not.
>>57
I admit it wasn't a good example, but it's good we agree that CL code doesn't satisfy the substitution principle, hence is not modular - and it doesn't matter what Lisp code looks like after macroexpansion, because the whole point of macros is that the programmer doesn't have to write the expanded code (or look at it, unless he's debugging macros).
And yes, I've used Lisp and know how ubiquitous macros are there - even setf is a macro! Even CLOS is semantically equivalent to a bunch of macros! There's a huge gap between what the Lisp programmer writes and what it expands to, and there's a reason Lisp macros have been largely rejected by the programming community at large, and have been incorporated into the mainstay languages in a more tame and guarded form. Macros are just too unpredictable and unwieldy to let them run rampant like (Common) Lisp does.
>>60
Ooh, the Wisp Wizard has an owie-owie. Pooh Wisp Wizard, he can't even define a function that would be polymorphic with a * -> * type parameter. Wun back to Mommy, Wispie Wizard, away fwom all these bad kids at that bad forum!

lel
lisper got #rekt

Oh, and another thing I've learned while programming with a lisp is that the slogan "code = data" is only half true. Sure, you can turn data into code, but not the other way around. The sexp syntax which, as Lispers claim, is the representation of the AST, is anything but. It is only a flattened, simplified symbolic representation: you cannot distinguish a function call from a macro call from a function parameter from a macro parameter from a special form! Pretty much the only form of codewalking you can do is check how many items are in a sexp, not their semantics. So you can write code-generating, template-style macros, sure - which is almost as easy to do in lots of contemporary languages, from Scala to Nemerle to Rust to Haskell - but not code-walking or code-transforming macros, at least not meaningfully code-transforming macros. You can't, for instance, write a macro that would automagically memoize all function calls in a code sample, or one that would perform a CPS transform. And that just means that the sexp-syntax that Lispers are so hyped up about is overrated. You can have code template without all the goddamn parentheses.

>>63
Try writing apply in haskell.

>>65
http://common-lisp.net/project/cl-cont/

>>66
So you seriously think that a [a] -> b function is impossible in Haskell?
As for the link:

Because compilers often expand standard macros into non-standard CL code, supporting all special operators is not sufficient to support all of Common Lisp. cl-cont makes special arrangements to support defun. Currently defgeneric and defmethod are not supported. Additional cases will be handled as they are exposed.

>>67
What about it? 
It's a code transforming macro.

Supporting every implementation is not something that you said was impossible, it's just tedious.

Also, give me a definition of apply in haskell.

>>68
http://okmij.org/ftp/Haskell/polyvariadic.html#polyvar-fn
Defgeneric and defmethod are not implementation-specific, they're part of the core language in ANSI Common Lisp.

>>69
They're allowed to expand into anything as long as the semantics are correct.

And that's not a definition of apply.

http://www.lispworks.com/documentation/HyperSpec/Body/f_apply.htm

Long back (1995-6) when I was still a college student (studying Math) I first saw Prolog. Chirs Martis, then boyfriend (now husband) of my friend Medha Patkar used to work for some company in SEEPZ and he was working on a project for some Japanese company. They had to migrate an older code base to a newer stack. I disremember the details (I dont think I knew much anyway) but he was learning Prolog as they were using a translater written in Prolog to help in the translation of the older codebase. I was a curious cuss then, and kept pestering him with questions. I was interested and wanted to learn Prolog. This was before we had access to the Internet. So my friend Anuprita took me to the British Council Library where she was a member. I saw a couple of Prolog books – pretty hard for me to understand as I had scant background in Programming (I did not even own a computer at that time). But I also saw a tiny booklet about another language called Lisp written by some Indian author. What intrigued me was the factorial program on the last page – this did not look like any program I had ever seen. I was more interested and my mom got scared and said, you're movin'with your auntie and uncle in bel air. I whistled for a cab and when it came near the license plate said fresh and it had dice in the mirror if anything I could say that this cab was rare but I thought, "nah, forget it yo home to bel-sir" I pulled up to the house about 7 or 8 and I yelled to the cabby yo holmes smell ya later looked at my kingdom I was finally there to sit on my throne as the prince of bel-air. Fast forward to 1998. I tried using CMUCL on my AMD 386DX with 8 MB of RAM. It was very hard to understand what to do at the REPL. Hardly any documentation. Fast forward somewhere 2001 and Internet world. I landed up on comp.lang.lisp and asked a few silly questions. Got my head bitten off seriously – especially by Naggum. But Erik Naggum, and Erann Gatt (Ron Garret) were the reason I persisted. Erann(Ron) by his Nasa stories really awed me. By this time I had also come across Greenspun’s tenth rule of programming...

>>63
hair-splitting
Stating a difference between mathematics and programming is not nearly so microscopic as hair splitting, nor does it require finesse or even action. It's more akin to those "do not eat" warnings on sachets of silica gel; a reminder for retards.

Yes, I'm good enough to learn and use Haskell, at least a moderate level
Buffoon, have you no shame? Why even speak when you know not what you speak about?

*farts violently on >>74*

*piss on >>73's computer*

install gentoo

shhhh

just install