I've read the UNIX Haters Handbook

I liked it.

Well, as long as by UNIX it means Crapple Macs, etc and not *BSD or Linux I'd probably like it too.

>>2
Macs are basically BSD and I have bitch tits

>>2
By UNIX it means UNIX, which includes *BSD, LINUX and every *n*x-like.

>>3
Macs are a little BSD, but mostly hipster faggot.

>>5
We're talking internal workings, not userbase.

Unix/Windows/Linux/BSD - outdated C/C++ crap.

We need a Lisp-OS.

>>7
Racket runs on bare metal.

>>8
Proof or GTFO.

>>9
http://lists.tunes.org/archives/lispos/1998-December/002514.html

But first you need to manage to compile OSKit.

>>10
couldnt boot from USB flash
doesnt recognize my shiny new NVidia card

what im doing rong?

>>11
what im doing rong?
Trolling.

OSKit is compatible with Linux drivers, and you can't compile three versions of gcc, oskit and racket in 20 minutes.

>>12
But does it run ED?

>>12
Linux
Lisp OS
gcc
you have just divided by zero!

_{^{LISP OS MY ANUS}}

Outdated by today's standards. Also, Plan 9 fixed most of the Unix problems.

>>16
Plan 9 is made of bunnies and autism.
I'll give it a try.

>>16
>Plan 9 fixed most of the Unix problems.
Is it written in LISP?



Two famous people, one from MIT and another from Berkeley (but working on Unix) once met to discuss operating system issues. The person from MIT was knowledgeable about ITS (the MIT AI Lab operating system) and had been reading the Unix sources. He was interested in how Unix solved the PC loser-ing problem. The PC loser-ing problem occurs when a user program invokes a system routine to perform a lengthy operation that might have significant state, such as IO buffers. If an interrupt occurs during the operation, the state of the user program must be saved. Because the invocation of the system routine is usually a single instruction, the PC of the user program does not adequately capture the state of the process. The system routine must either back out or press forward. The right thing is to back out and restore the user program PC to the instruction that invoked the system routine so that resumption of the user program after the interrupt, for example, re-enters the system routine. It is called ``PC loser-ing'' because the PC is being coerced into ``loser mode,'' where ``loser'' is the affectionate name for ``user'' at MIT.

The MIT guy did not see any code that handled this case and asked the New Jersey guy how the problem was handled. The New Jersey guy said that the Unix folks were aware of the problem, but the solution was for the system routine to always finish, but sometimes an error code would be returned that signaled that the system routine had failed to complete its action. A correct user program, then, had to check the error code to determine whether to simply try the system routine again. The MIT guy did not like this solution because it was not the right thing.

The New Jersey guy said that the Unix solution was right because the design philosophy of Unix was simplicity and that the right thing was too complex. Besides, programmers could easily insert this extra test and loop. The MIT guy pointed out that the implementation was simple but the interface to the functionality was complex. The New Jersey guy said that the right tradeoff has been selected in Unix-namely, implementation simplicity was more important than interface simplicity.

The MIT guy then muttered that sometimes it takes a tough man to make a tender chicken, but the New Jersey guy didn't understand (I'm not sure I do either).

>>18
Is it written in LISP?
LISP wouldn't be the ultimate panacea either, sure you'd have incremental compilation, a completely garbage collected, dynamic, etc OS, but in the end it would become bloated (like emacs), as you can add shit without too much effort.
Still, it would be much better than current OSes.

Other critics of Plan 9 include those critical of Unix in general, where Plan 9 is considered the epitome of the "Worse is better" school of operating system design.

>>19
It would. But usual Lisps dont allow precise code decomposition on function level. You cant for example reuse function namespace system as filesytem. No distributed garbage collection, for use a bunch of machines as single address space. So, for an OS, we need a special Lisp. Also, you can easily replace crappy Unix filestreams with lazy lists.

<-- check em dubz