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?

install BSD/Gentoo

>>2
Explain.

i pull my dik out of ur ass

Install Cygwin/Win32

>>1
This is getting ridiculous. WHO THE FUCK ARE YOU QUOTING? WHY WON'T YOU TELL?

>>6
Ctrl+F

install BSD/Gentoo

>>7`
>2014
>not using a OSX
stay pleb

>>1
PROTIP: I'm the "rename GNU/Linux as BSD/Linux guy".
I'm also not the install BSD/Gentoo guy.
That's just some guy who enjoys spam.

>>1
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.
I hate to break it to you, but you're a retard, OP.
The GNU approach to UNIX is ``attempt to do everything all at once, then fail on all fronts''.
The traditional UNIX philosophy is ``do one thing really well, then combine with other tools''.
GNU is to the UNIX philosophy as Microsoft is the the UNIX philosophy.

I suspect their creation of monolithic garbage heaps rather than nice modular utilities is to prevent anybody from actually using their applications in other programming projects. That is, using them without modifying the source.
If the only way you can reuse feature <whatever> from emacs in your own project is to actually modify the source, then they prevent you from dodging their shitty viral license by calling a binary.

That's some proprietary tier assholery right up there.
Seriously, it's the kind of thing Apple would do.

>>10
I'm a Lisp programmer, I think the UNIX philosophy is garbage.

Some GNU programmers are or were Lisp programmers. GNU's approach to UNIX could be called a Lipsish approach to UNIX. That being said UNIX is the antithesis to Lisp.

Please see my other posts on this board and the other board for reasons why the UNIX philosophy is retarded, I do not care to repeat them.

>>12
Yeah, sorry, but Lispers don't really have any credibility.
They have the most immature approach to programming of any language fanboys.
The approach of "I'm writing code for myself. My code is for me, it will never be shared. Even if it is shared it will never need to be read of modified by others because I'm perfect and my code is perfect.".

There's a good reason Lispers don't actually get employed as programmers, and it's not the HURRR DURRR CONSPIRACY TO KEEP THE PERFECT MASTER RACE DOWN that Lispers often complain about.

>>12
Please see my other posts on this board and the other board for reasons why the UNIX philosophy is retarded, I do not care to repeat them.
Yeah ok, I'll check all messages signed Anonymous on this board and the other board, I do care to read them.

>>13
None of what you said is true.

>>14
They're not that hard to find e.g. look at (one of) the secret society threads on the front page of lounge on the other board.

>>10
GNU is to the UNIX philosophy as Microsoft is the the UNIX philosophy.
You are correct. OP mentioned, that he is a "Lisp wizard", so he "views all current operating systems as retarded."

Basically, he hopes that GNU would embrace and extinguish Unix/Linux, and the flower of Lisp OS would grow on Unix' decomposing body.

>>16
What a horrific thought.
It's as if he doesn't even write code and wants to punish the people who do
.

>>16
I have no such hopes.

GNU has embraced Scheme more than Lisp anyway, and as an extension language, not a systems language (as was originally promised)

I simply prefer a more useful and understandable UNIX environment to a ``modern'', ``minimalistic'', ``elegant'' and ``simple'' one, given that I use one.

>>15
It's all true though.
Their retarded hermit hipster attitude is the reason Lisp is so rare.
Nobody shares.
Nobody writes standardised libraries.
Nobody writes quality code that's maintainable by others.
It's essentially a write-only language like Perl; except that people who use Perl are really nice and Lispers are hipster dickheads.

>>17
I don't ``write code'', I conjure the spirits of the computer with my spells.

I don't want to punish those of you who write code, rather I want to help you obtain mastery over the essence of the machine.

>>19
Just repeating things doesn't make them true.

>>21
Same goes for you.
If you want to prove me wrong then explain Lisp's lack of quality libraries and opensource projects.

>>22
Lisp has plenty of quality libraries though.

**** Development
+ ASDF
  + Build system.
+ Quicklisp
  + Library package manager.
+ SLIME + Swank + Paredit + Redshank
  + Emacs extensions.
**** General
+ Alexandria
  + Standard library.
+ Anaphora
  + Anaphoric macro library.
+ Cells
  + Data flow extensions.
  + GUI framework (e.g. celtk cells-gtk).
+ CL-PPCRE
  + Regular expressions library.
+ CLIM
  + GUI framework.
  + Mainly commercial.
+ Iterate
  + Alternative to LOOP.
+ optima
  + Pattern matching.
+ SERIES
  + Lazy evaluation.
  + Iteration.
+ SPLIT-SEQUENCE
  + Partitioning sequences.
+ LOCAL-TIME
  + Time and dates.
  + Based on Eric Naggum's History of Time.
+ metabang-bind
  + Combines labels, let, flet, destructuring-bind, with-slots,
    with-accessors, and multiple-value-bind into one form.
  + Extensible.
**** Implementation abstraction
+ Bordeaux threads
  + Standardizes Threads.
+ CFFI
  + Standardizes C interop.
+ CL-FAD
  + Standaridzes files and directories.
+ Closer to MOP
  + Meta object protocol.
+ Trivial backtrace
  + Standardizes backtrace printing.
+ Trivial features.
  + Standardizes =*features*=.
+ Trivial Gray streams
  + Ensures CLOS streams (already defacto in most implmentations).
+ Trivial garbage
  + Standardizes weak pointers and weak hash-tables.
+ USOCKET
  + Standardizes the sockets interface.
**** Systems
+ Babel
  + Character encoding.
+ Chipz
  + Decompression.
+ CHUNGA
  + Chunked streams
+ CL+SSL
  + Interface to OpenSSL.
+ Flexi-streams
  + Stream interface over streams for character encoding.
+ Ironclad
  + Cryptography.
+ Nibbles
  + Reading and writing machine types.
+ Salza2
  + Compression.
**** Graphics
+ CL-JPEG
  + JPEG input and output.
+ CL-OPENGL
  + Bindings for OpenGL.
+ CL-VECTORS
  + 2D primitive drawing library.
+ CLX
  + Bindings to X.
+ PNG-READ
  + PNG input.
+ Skippy
  + GIF input and output.
+ Vecto
  + High level interface to CL-VECTORS.
+ ZPB-TTF
  + Parses ttf files.
+ ZPNG
  + PNG output.
**** Web
+ Hunchentoot
  + Web server.
+ Drakma
  + HTTP client.
+ RFC2338
  + Multi-part form data.
+ Parenscript
  + Javascript transpiler.
+ CL-WHO
  + HTML DSL.
+ Postmodern
  + Postgres interface.

>>23
That's all?
And this language is 50 years old?
Wow, it's even less popular than I thought.

>>22
There's plenty of great open source projects too, Maxima, ACL2, Lisa...

Why do you think there isn't?

>>24
No that is not all, not even close to it...

>>25
Because the Lisp philosophy has always been ``I'm the smartest, therefore reinventing the wheel is a good idea.''.
And ``Sharing? What's sharing. Standards and libraries are for ENTERPRISE programmers.''.

>>24
Keep in mind a lot of great Lisp programs are lost.

Mirai was used to e.g. animate Golem in Lord of the Rings, and develop Mario 64, but due to legal battles over who owned the programs died. The precursor to it (S-graphics) was used in the 80s widely in the television industry.

Genera was an entire operating system.

Entire machines were built especially to run Lisp, from the Fujitsu Facom Alpha to the Symbolics 3600. Apple developed a wide variety of software in Macintosh Common Lisp from Dylan to Sk8 to finders.

Microsoft prototyped Word on the Mac in Common Lisp.

I can go on and on...

>>27
But that's not the Lisp philosophy...

The FSF was for example, started by a Lisp programmer.

>>28
So you actually had a Lisp machine?
You actually had a Lisp OS?
Then why do Lispers keep talking as if these things haven't, and that they're bound to in the near future?

>>27
Lisp has one of the greatest standards in existence: ANSI Common Lisp. It's very stable and well crafted. If you write a conformant program, it is very well likely to run on many Common Lisp implementations. However, Common Lisp implmentations provide various extra tools and extensions, (on top of which small libraries were built). It's not a perfect standard, but it's very good.

So I don't know why you think Lisp people don't like standards...

>>29
Past tense.
Rimmus later realised that it's easier to steal credit for other's work and never wrote a line of code again.

>>30
Yes there were a variety of Lisp machines and Lisp OSes from a number of vendors.

You had super computers like the Connection Machine (as seen in Jurrasic Park, and incorrectly referred to as a Cray), to NuBUS extension boards for Macintosh computers (Texas Instruments Microexplorer, Symbolics Ivory etc.) and many things in between.

>>32
But Lisp programmers share code all the time, for example a Lisp programmer from MSI Japan recently got permission to open source much of the utilities he wrote there, to the benefit of all other Lisp programmers.

Most Common Lisp implementations are open source.

As mentioned there's hundreds of community libraries, and people collaborate on things all the time.

>>9-15,21-27,31-34
Who are you quoting?

>>35
The THE SUSSMAN you annoying person, now stop asking!

>>36
Why didn't you say so earlier! It's always a pleasure to read quotes from the THE SUSSMAN. I now recall that you're the reason why I came here and stayed. Have a good day, Sir.

>>23
I envy you, Lisp wizard. Your world is wonderful, I spent a whole year discovering all this. At the end of the day, I still haven't found a job or a single friend. I'm afraid I have to stick with what the other programmers speak. A Lisp job or a Lisp friend would take at least 10 more years of dedication.

I can't afford it.

>>18
GNU has embraced Scheme more than Lisp anyway, and as an extension language, not a systems language (as was originally promised)
I haven't heard of any system programming geared implementation of Scheme, meaning we have no replacement for C/C++. Most Scheme implementations are simple interpreters or compile to C/C++, or some MSIL or JVM (like Closure).

>>38
Do not envy me. I am also an ENTERPRISE SEPPLES DEVELOPER.

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