Slashdot Mirror


Andy Tanenbaum Releases Minix 3

Guillaume Pierre writes "Andy Tanenbaum announced the availability of the next version of the Minix operating system. "MINIX 3 is a new open-source operating system designed to be highly reliable and secure. This new OS is extremely small, with the part that runs in kernel mode under 4000 lines of executable code. The parts that run in user mode are divided into small modules, well insulated from one another. For example, each device driver runs as a separate user-mode process so a bug in a driver (by far the biggest source of bugs in any operating system), cannot bring down the entire OS. In fact, most of the time when a driver crashes it is automatically replaced without requiring any user intervention, without requiring rebooting, and without affecting running programs. These features, the tiny amount of kernel code, and other aspects greatly enhance system reliability."In case anyone wonders: yes, he still thinks that micro-kernels are more reliable than monolithic kernels ;-) Disclaimer: I am the chief architect of Globule, the experimental content-distribution network used to host www.minix3.org."

528 comments

  1. live-CD by DreamerFi · · Score: 5, Informative

    And you can try it out on your current PC - the download is a live-cd!

    1. Re:live-CD by xgadflyx · · Score: 2, Funny

      Well before I burn the bandwidth, does it have KDE or Gnome?

      --
      Civilization, the death of dreams.
    2. Re:live-CD by BushCheney08 · · Score: 1

      I'm guessing this is a command-line only OS. Minix was developed to be a unix-like OS that students could easily get their hands and brains around and into. Slapping a nice GUI and all sorts of extra crap defeats that purpose.

      --
      Be a real patriot: Question authority. Think for yourself. Formulate your own conclusions.
    3. Re:live-CD by hal2814 · · Score: 1

      "Slapping a nice GUI and all sorts of extra crap defeats that purpose."

      No, slpaaing a "nice" GUI would be well within the purpose of Minix. Slapping something as insanely complicated as X11 on Minix would be the part that defeats the prupose. Too bad there's not a windowing system built to be as simple as Minix.

    4. Re:live-CD by m50d · · Score: 2, Informative

      Not necessarily. Just make it posix-compliant (it should be pretty close) and able to run X (which shouldn't require any core OS changes if you're not worried about acceleration, so shouldn't affect the ability of students to understand the main thing), and then you can compile any fancy gui you like for it, with no effect at all on the main system.

      --
      I am trolling
    5. Re:live-CD by BushCheney08 · · Score: 1

      Actually, Minix is Posix compliant and I believe there is a version of X11 for Minix out there. Getting KDE or Gnome to compile and run, however, is up to you.

      --
      Be a real patriot: Question authority. Think for yourself. Formulate your own conclusions.
    6. Re:live-CD by Ed+Avis · · Score: 2, Informative

      I believe there has long been an X11 port for Minix-386 (an enhanced and slightly bigger version of Minix running in protected mode on 386 boxes).

      If you want a simpler windowing system you could try MGR.

      --
      -- Ed Avis ed@membled.com
    7. Re:live-CD by the+big+v · · Score: 3, Informative

      Long ago, in a land far-far away, a fellow at Bell Labs (IIRC, named Steve Uhler) released for the Sun3 (ie, 68030 based boxes) a windowing system called MGR. It was wickedly simple, and entirely network transparent. That is, if you could telnet/ssh/whatever to a remote system and open a shell, you could run graphical applications.

      The core was extremely small and simple. Unfortunately, the apps were few and far between, existing mostly of basic tools like a terminal and a "Mickey Mouse Watch" emulator. It would have filled your wish for a nice GUI which is extremely simple to implement. The major drawback was parts were writtin in 68030 assembler, making portability challenging.

      --
      The only ``intuitive'' interface is the nipple. After that, it's all learned.
    8. Re:live-CD by 3dr · · Score: 1

      I remember MGR.
      I ran it on my hacked 68010-based AT&T 3b1. The hack was disconnecting the A20(?) address pin on the 68010 to allow MGR to access the framebuffer memory space, if I remember correctly. MGR was pretty cool but underutilized.

    9. Re:live-CD by m50d · · Score: 1

      Official policy is that KDE shouldn't require anything more than that (well, it depends on some gnu tools but those should run on any posix-compliant system). Of course in practice it's not quite that simple, but it should be very much doable.

      --
      I am trolling
    10. Re:live-CD by ctzan · · Score: 0

      I managed to get MGR up and running with all stuff
      on Linux.
      I had to hack it a bit - but no particularly
      difficult stuff.

  2. Phew by Anonymous Coward · · Score: 5, Funny

    Now we can all switch over from Linux, at least until Hurd ships.

    *pummeling ensues*

    GNU/Hurd!! I meant GNU/Hurd!!!

    1. Re:Phew by Anonymous Coward · · Score: 0

      No, no -- it's, "GNU/Linux! I meant switch over from GNU/Linux!" Although now that you mention it, I wonder if RMS would get uptight about you not prefixing Hurd with GNU, the way he does with Linux. Hmm...

    2. Re:Phew by Anonymous Coward · · Score: 0

      > GNU/Hurd!! I meant GNU/Hurd!!!

      Why? You were talking about a kernel, and so is Hurd. Were you talking about the complete system, that would be GNU.

      Don't worry, I really don't expect you (nor the average ./tter) to know what Linux really is.

    3. Re:Phew by Anonymous Coward · · Score: 0

      i was thinking it ought to be GNU/Hurd in order to differentiate with GNU/linux, but then I realised - no. the Hurd was always meant to be the kernel for the entire GNU operating system. so the Hurd is the Hurd, but it would be the GNU-OS. Linux was just this stranger who walked into town and stood up to M$ (in the meantime shooting all the other M$ enemies like Solaris, SGI etc as well, but i guess it's not true the enemy of your enemy is my friend...)

    4. Re:Phew by Anonymous Coward · · Score: 0

      Actually, it's called GNU Hurd...

    5. Re:Phew by Haeleth · · Score: 2, Insightful

      GNU/Hurd!! I meant GNU/Hurd!!!

      No, you meant GNU. Just GNU. The only reason we say "GNU/Linux" is that that involves adding a non-GNU kernel (Linux) to the GNU operating system. But when you're using the Hurd as your kernel, you are just using the GNU operating system, the way Stallman intended it, and the proper name for the system is "GNU".

      This is, of course, all moot, given that the Hurd has about 5 users...

    6. Re:Phew by acid_zebra · · Score: 0, Troll

      He was making what is colloquially known as a 'joke'. Look it up sometime ,huh?

      --
      -- No Sig is a Good Sig
    7. Re:Phew by ajs318 · · Score: 2, Informative

      No. You would be switching the kernel from Linux to Minix {or The Hurd}, whilst retaining a GNU userland. So you would be switching over to GNU/Minix, or GNU/Hurd.

      There are two parts to an operating system; the kernel {which provides a very low level interface to the computer's hardware} and the userland {which provides an interface to people}. The GNU project has created a viable userland, but is still having difficulty producing a kernel. Linus Torvalds -- then a student of Tanenbaum -- created Linux, originally a simple kernel which has now grown into something much bigger.

      When you type "ls" {which is a userland command} into the shell {another userland process, which accepts commands from users [by means of a call to the kernel], passes them to the process sheduler [another userland process ..... often having PID=1 and capable to bring down a system if inelegantly terminated] and sends back the output generated from the command}, the "ls" command is invoked. The kernel checks to see if there is an undamaged copy of "ls" in memory already, and if not loads one. The "ls" command passes a call to the kernel to read the directory listing from the disk, then generates some human-readable output from this data. The shell calls the kernel to write this information to the screen.

      It was when hackers wrapped a GNU userland around the Linux kernel that the magic really began to happen. Of course, you could just as easily wrap a GNU userland around the FreeBSD kernel, or a BSD userland around Linux, but GNU and Linux just hit it off the best.

      The delicious irony of all this is that Linux really was first created just to prove a point: that a monolithic kernel could sometimes outperform a microkernel {which Tanenbaum disputed}. Though apparently counter-intuitive, this is not really all that surprising when you think about it a little harder: certain Typical Real Life Operations are predictable enough to optimise very hard, and a monolithic kernel naturally supports harder optimisation than a microkernel at the expense of some flexibility. If the operations you optimise hardest happen commonly enough, then the performance gain can be significant. {Cf. if you live in an area with plenty of sunshine, waste disposal by landfill, and your water heater runs on almost any fuel besides electricity, then terry nappies will definitely be greener; whereas if your household waste is burned in a reasonably modern power plant, your water heater is electric and prevailing weather conditions are such that you need to use a tumble drier for the majority of your washing loads, disposables might work out better.}

      --
      Je fume. Tu fumes. Nous fûmes!
    8. Re:Phew by KenSeymour · · Score: 1

      IIRC, gcc did not work on Minux. There was some funky C compiler you had to use. Pre Minux 3 was designed to work on an XT, so there
      were severe memory restrictions. There was a set of patches for 386 protected mode for Minux, but I could never get it to work on my 386 PC.

      A TCP/IP stack was another thing that was lacking in Minix.

      Good think Linux came along.

      I still have the Prentice Hall box set. It was interesting reading through the printed source code.

      --
      "We can't solve problems by using the same kind of thinking we used when we created them." -- Albert Einstein
    9. Re:Phew by Anonymous Coward · · Score: 3, Informative
      So you would be switching over to GNU/Minix, or GNU/Hurd.

      True, but you overlooked the fact that I said, "I meant switch over from GNU/Linux!" [emphasis added]. You think you're contradicting me, but you're not.

      Linus Torvalds -- then a student of Tanenbaum

      Torvalds was never a student of Tanenbaum. Like many computing students the world over, myself included, he learned something about OS hacking using Minix, which is Tanenbaum's baby, but he wasn't a student of Tanenbaum. Tanenbaum teaches at Vrije Universiteit in the Netherlands; Torvalds went to Helsinki University in Finland.

      Linux really was first created just to prove a point: that a monolithic kernel could sometimes outperform a microkernel

      No, that's not right either. Presumably this fiction follows from your earlier fiction about Linus being a student of Tanenbaum. Tanenbaum's take on the matter is as follows.

      Before there was Linux there was MINIX, which had a 40,000-person newsgroup, most of whom were sending me email every day. I was going crazy with the endless stream of new features people were sending me. I kept refusing them all because I wanted to keep MINIX small enough for my students to understand in one semester. My consistent refusal to add all these new features is what inspired Linus to write Linux. Both of us are now happy with the results. [Source: Tanenbaum's FAQ]

      Go brush up on your research skills. We can work on your stylistic elements after you get your facts straight.

    10. Re:Phew by Surt · · Score: 1

      Hey, with 5 users that's a 25% daily growth rate since yesterday. If these trends continue, zow!

      --
      "Who is the Journal of Quantum Physics going to believe?" --Stephen Hawking
    11. Re:Phew by forkazoo · · Score: 2, Informative

      Ah, I think I understand this kernel/userland distinction. What you are saying is that Linux is just a kernel, and the GNU people make X11 and KDE, which is how people actually interact with the system. Oh, wait, no they didn't. They made ls and whatnot. Oooooh, they makes it surely worth noting loudly everytime I talk about my OS.

      To be fair, I do prefer the GNU userland to the BSD stuff. None of it would exst without gcc, which is probably the single most important Open Source project in existence. But, even so, I find the "GNU/Linux" issue to be just a bunch of whiny pedantry.

    12. Re:Phew by ctzan · · Score: 0

      "passes them to the process sheduler [another userland process ..... often having PID=1 and capable to bring down a system if inelegantly terminated]"

      nowhere in unix, linux, *bsd, etc is the
      process scheduler a "userland process".
      PID=1 is 'init'
      It seems you have read some educational
      material about Windows and made a mess
      out of it.

      I had a good laugh, anyway.
      Such self-satisfied ignorance.

    13. Re:Phew by Pres.+Ronald+Reagan · · Score: 1, Funny

      Yeah, I wouldn't expect the average Dotslasher to understand something as complicated as that either.

      Jackass.

      --

      Abortion is advocated only by persons who have themselves been born.
      --Ronald Reagan
    14. Re:Phew by Anonymous Coward · · Score: 0
      IIRC, gcc did not work on Minux.

      yes it fscking did... here's the bl00dy evidence...

      Path: gmdzi!unido!mcsun!news.funet.fi!hydra!klaava!torva lds
      From: torva...@klaava.Helsinki.FI (Linus Benedict Torvalds)
      Newsgroups: comp.os.minix
      Subject: Re: gcc 1.40 for Minix-386
      Message-ID: <1991Aug20.121735.19947@klaava.Helsinki.FI>
      Date: 20 Aug 91 12:17:35 GMT
      References: <1991Aug19.220059.27322@Informatik.TU-Muenchen.DE>
      Organization: University of Helsinki
      Lines: 26

      In article <1991Aug19.220059.27...@Informatik.TU-Muenchen.DE> rom...@Informatik.TU-Muenchen.DE (Kai-Uwe Rommel) writes:
      >Someone reported a while ago that compiling gcc 1.40 for Minix-386 would
      >be straightforward with the running gcc 1.37. I have tried this.
      >Compiling gcc was not that difficult. But I have a problem now.
      >cc1 cores on signal 6 when
      >a) a file with floating point is compiled
      >b) -O is used.
      >
      >Kai Uwe Rommel
      >

      Ok. I'm the one that reported porting was easy. Seems I didn't explain
      enough :-).

      This is what happens when you either have compiled cc1 without using
      -msoft-float (the gcc from plains uses soft-float by default, but if you
      compile cc1-1.40 with itself you must put a -msoft-float in the
      makefile). The other possibility is that you aren't using the crt0.o
      that was shipped with the original gcc-1.37.1 by black&tobin (?). It is
      needed to get the signal handler started.

      The thing to do is recompile cc1 from scratch while using -msoft-float,
      or changing DEFAULT_TARGET to 0 in tm.h (and then recompiling cc1).
      This should fix the problem.

      Linus (torva...@kruuna.helsinki.fi)
    15. Re:Phew by arkanes · · Score: 1

      I feel obliged to point out that in addition to being wrong about the motivations, he's also wrong that Tanenbaum thought that monolithic kernels were slow. Everyone knew that monolithic kernels were faster - fewer context switches, no message-passing overhead. His claim was (and is) that microkernels were better, not that they were faster. And the success of Linux really doesn't address the fundamental design and architetural differences between micro and macrokernels at all.

    16. Re:Phew by The+Warlock · · Score: 1

      They didn't make KDE, but they did make GNOME.

      But yeah, it's a meaningless issue, a distinction without a difference.

      --
      I've upped my standards, so up yours.
    17. Re:Phew by ajs318 · · Score: 1
      So, I bought into the legend. Well, I stand corrected now. It does sort of make me wonder what they will say about Linus when he is dead, though .....
      [Tanenbaum's] claim was (and is) that microkernels were better, not that they were faster.
      A faster kernel will nearly always be better in Real World applications, where speed is as make-or-break important as stability. But I can't argue that for learning about how things work a more modular approach - where you can just ignore whole chunks in the name of simplification - is a good thing.
      And the success of Linux really doesn't address the fundamental design and architetural differences between micro and macrokernels at all.
      Maybe not. For a truly valid experiment {as opposed to just observing that the most successful OSes generally tend to have monolithic kernels and making an inference from that}, you would have to simultaneously release two OSes -- one with a microkernel, one with a macrokernel, but otherwise identical -- and see which one took off.
      --
      Je fume. Tu fumes. Nous fûmes!
    18. Re:Phew by TheoMurpse · · Score: 1

      GNU/Hurd!! I meant GNU/Hurd!!!

      That reminds me of a joke:

      RMS walks into a bar and says, "Hey, have GNU Hurd the news lately? We finished the kernel!"

  3. Love this quote by strider44 · · Score: 5, Interesting

    While I could go into a long story here about the relative merits of the two designs, suffice it to say that among the people who actually design operating systems, the debate is essentially over. Microkernels have won.

    In retrospect that might have been a bit overconfident.

    1. Re:Love this quote by strider44 · · Score: 4, Interesting

      In the meantime, RISC chips happened, and some of them are running at over 100 MIPS. Speeds of 200 MIPS and more are likely in the coming years. These things are not going to suddenly vanish. What is going to happen is that they will gradually take over from the 80x86 line. They will run old MS-DOS programs by interpreting the 80386 in software. (I even wrote my own IBM PC simulator in C, which you can get by FTP from ftp.cs.vu.nl = 192.31.231.42 in dir minix/simulator.) I think it is a gross error to design an OS for any specific architecture, since that is not going to be around all that long. Another one. Reading predictions from fifteen years ago is really quite entertaining, showing that even the smartest people can get things slightly wrong.

    2. Re:Love this quote by Anonymous Coward · · Score: 2, Insightful

      ...which is exactly what everything post Pentium Pro does... So yes, he got it exactly right...

    3. Re:Love this quote by E1ven · · Score: 4, Interesting

      Keep in mind, that modern CPU architectures tend to translate to a much more RISC like set of instructions internally. It wouldn't be horribly wrong to argue that they are translating, although using dedicated Hardware, instead of software.

      And while it's not 15 years out, IIRC, the IA-64 architecture did actually use a software translator. (Although to be fair, I think that was more of a VLIW style chip)

      While I don't claim to understand the entire 15 year history of chip production perfectly, I wouldn't be so quick to dismiss his comments. He was more right than he was wrong.

      --
      Colin Davis
    4. Re:Love this quote by mklencke · · Score: 2, Informative

      > They will run old MS-DOS programs by interpreting the 80386 in software.

      Well, this is partly true :-) I use Dosbox quite often for playing old games, tinkering with TASM, etc.

    5. Re:Love this quote by Anonymous Coward · · Score: 0

      And the brand new 2005 release of Minix 3 runs on ... 80x86 :)

    6. Re:Love this quote by Anonymous Coward · · Score: 0, Insightful

      Keep in mind, that modern CPU architectures tend to translate to a much more RISC like set of instructions internally. It wouldn't be horribly wrong to argue that they are translating, although using dedicated Hardware, instead of software.

      Also keep in mind that the difference between RISC and CISC is that CISC has a translation layer between the user-visible instruction set and the native hardware instruction set (microcode), where as RISC does not.

    7. Re:Love this quote by fandrieu · · Score: 1

      lol, Minix 3 requirements:

      To run MINIX 3, you need a PC driven by a 386, 486, or Pentium CPU or compatible...

    8. Re:Love this quote by MoogMan · · Score: 1

      To be fair, CISC and moreover, RISC/CISC architectures "won" more due to marketing spin and the like. RISC is still superior technology, so logically it should have superceeded CISC and RISC/CISC.

    9. Re:Love this quote by MikeFM · · Score: 4, Insightful

      That'd be more convincing if I could see a microkernel OS that didn't suck. The theory is great.. sort of like object oriented programming.. but doesn't always work out. The biggest problem seems to be that that extra layer of abstraction slows things down (which makes sense really). Then you have to weigh the benefits of running faster and leaner or easier programming. From a programmers point of view most will like the abstracted and easier option because you can spend more time writing code and less time debugging and fixing but real world usgae doesn't always work well with that.

      Still.. as fast as modern computers are I think we may be reaching a point where raw speed is less important and well designed microkernels can probably run almost as fast as monolithic kernels. If heavy usage servers can be run as virtual machines in Xen then why not use a microkernel too?

      So. Any examples of microkernel OS's that handle heavy server load, function well as a desktop, and can handle multimedia tasks like gaming? OS X uses BSD under a microkernel I think but my experience is that it is slow and the tests I've seen have shown that Linux performs a lot better on it than OS X (no idea if that was due to microkernel use). I'd find it hard to believe that with solid numbers showing that microkernel is just as fast and without additional overhead that someone like Linus wouldn't use it since it's an easier programming model (better for security, stability, etc).

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    10. Re:Love this quote by luzr · · Score: 1

      > To be fair, CISC and moreover, RISC/CISC architectures "won" more due to > marketing spin and the like. RISC is still superior technology, so logically > it should have superceeded CISC and RISC/CISC. To be really fair, RISC was made obsolete by superscalar architectures. The main advantage of RISC - simple decoder - is no longer important. Meanwhile, main disadvantage of some RISC architectures - bulky code - has bad impact on performance as it screws cache. Note also that recent PowerPC designs (G5) mark the end of RISC era, as its superscalar architecture has quite complicated decored that converts ISA "RISC" instructions into internal "RISC" instructions, which makes it quite similar architecture to current x86 designs.

    11. Re:Love this quote by ucahg · · Score: 1

      How does QNX stack up?

      Honest question, I don't know much about it, but I know it exists and is apparently rock-solid for embedded devices.

    12. Re:Love this quote by MikeFM · · Score: 2, Informative

      I tried it about 8 years ago so my experience is probably way outdated. Then it wouldn't even boot on about 7 of 10 of my PCs and the ones that did boot were pretty limited. I think it was QNX that had one feature I did find interesting though.. the ability to move your logged in GUI session from client machine to client machine without shutting apps down or logging out. It was a pretty cool feature similar to what we can do with VNC today but smoother. I'd love to see that work in X. (If that wasn't QNX then I have no idea what it was!)

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    13. Re:Love this quote by Intron · · Score: 1

      Hold on, I think there's a '386 equivalent in my washing machine control panel. Does it have a driver for "spin cycle"?

      --
      Intron: the portion of DNA which expresses nothing useful.
    14. Re:Love this quote by Anonymous Coward · · Score: 0

      Never mind that the POWER5+ (based on the POWER4 core that the G5 is also a derivative, both use the same instruction set) is the fastest general purpose processor available in the world today.

    15. Re:Love this quote by tezbobobo · · Score: 1

      And yet it is not available for Apple yet. I think I'll have a busy weekend.

    16. Re:Love this quote by schotter · · Score: 2, Interesting

      So much of FreeBSD's kernel was shoehorned into XNU that it's doubtful you could call it a microkernel anymore -- they don't usually contain networking stacks and firewalls and things, or at least that how much theory I remember about them. I've seen people call XNU a Frankenkernel though.

    17. Re:Love this quote by ChrisDolan · · Score: 2, Informative

      How about Mac OS X and Windows NT/2000/XP? Those are microkernel-based architectures. OS X uses Mach under the hood. Some BSD variants also support running on otop of Mach.

    18. Re:Love this quote by DrXym · · Score: 3, Informative

      QNX Neutrino is an example of a microkernel which doesn't suck. In fact QNX sees heavy use in realtime environments, where both space and performance matter a great deal. Some applications of QNX put considerable importance on the thing not collapsing in a heap after a failure of some part.

    19. Re:Love this quote by RAMMS+EIN · · Score: 2, Insightful

      ``While I could go into a long story here about the relative merits of the two designs, suffice it to say that among the people who actually design operating systems, the debate is essentially over. Microkernels have won.

      In retrospect that might have been a bit overconfident.''

      Perhaps, but it's true as stated. The consensus among OS designers really was that microkernels were superior. Linus opted for a monolithic kernel, because he didn't believe in Microkernels, but he was the odd one out. Linux's success also doesn't demonstrate superiority of monolithic kernels over microkernels. Linux's success is due to the enormous mindshare among developers and users, not the design.

      Also, Linux isn't a pure monolithic kernel. Almost everything is loaded as a module these days, and modules can communicate through message passing, and can even be implemented is userspace in some cases (e.g. filesystem drivers with FUSE). Even the direct function calling that modules do can be seen as just an optimization of what MINIX does with message passing.

      --
      Please correct me if I got my facts wrong.
    20. Re:Love this quote by sinserve · · Score: 1

      Worse Is Better.

    21. Re:Love this quote by wilsone8 · · Score: 3, Informative

      The original Windows NT architecture might have been a microkernel. But ever since the 4.0 version where Microsoft pulled the video subsystem into kernel space, there is no way you can still call that a microkernal. And they have only been pulling more and more into kernal space (for example, large portions of the IIS 6.0 HTTP processor actually run in kernel space on Windows Server 2003).

      --
      The real problem is not whether machines think but whether men do. - B.F. Skinner
    22. Re:Love this quote by AKAImBatman · · Score: 2, Insightful

      To be really fair, RISC was made obsolete by superscalar architectures.

      I'm sorry, but, HUH? Superscalar architectures were really only made possible by RISC platforms. In traditional CISC, the variety of instruction structure made it very difficult to order the instructions for multi-execution. Not to mention that the silicon was already rather convoluted in CISC structures, thus making it even more difficult to fit superscalar execution.

      The truth is that RISC won out. And so did CISC. Make sense? Allow me to explain:

      The key concept behind RISC was that it simplified the silicon sufficiently to ramp up the clock speed in exchange for requiring more instructions to perform the same task as CISC. Since a higher clock speed can more than make up for any per-instruction performance differences, the early 90's was ruled by high speed chips such as Alphas.

      However, CISC chips retained several features, not the least of which was the ability to build a far simpler compiler. Thus a compromise was reached. Microcode was added to RISC chips, thus making them appear to be CISC chips. All the improvements in clock speed were retained, but the chip had an extra pipeline stage to convert a short CISC instruction into a long (and hopefully Superscalar!) set of RISC instructions.

      And now you know why nearly every RISC chip in existence had Superscalar execution prior to it being added to the Pentium. (Sorry, but Intel was REALLY late to the game on most of this high-performance stuff. Fortunate for them, Intel has a rather massive R&D department that was able to develop combinations of experimental chip technology far faster than any of their competitors.)

    23. Re:Love this quote by gmack · · Score: 1

      Your kidding right? Modules != micokernel.

      The whole point of a microkernel is that each module exists in it's own address space so it can't stomp on other module's memory if it crashes. Linux exits all on one address space and it's inter module communication most often consits of passing around memory pointers.

      Sure there is FUSE but it's not used for anything that needs to be fast.

    24. Re:Love this quote by Anonymous Coward · · Score: 0

      I don't think Tanenbaum can be considered one of "the smartest people". "People with the biggest ego", yes - but not smartest. Not that he's stupid, of course (in fact, he's probably smarter than a lot of people out there), but he doesn't even come close to a Stephen Hawking or Albert Einstein.

    25. Re:Love this quote by slavemowgli · · Score: 1

      Nobody's using IA-64, though - it's already dead. Those who actually need 64 bit processors (and let's face it, they're still few and far between) are more likely to use AMD's x86_64.

      And outside of that, well... just open your eyes and look at the world. Pretty much everyone's using x86 chips (with some Ultrasparcs thrown in for bigger iron), with the only real exception being embedded systems, where ARM reigns supreme.

      Given that, I'm not really sure how you can find even the smallest grain of truth in the statement "x86 is dead, and in the future, everyone will use RISC chips that emulate it in software". It's simply not true - it wasn't 15 years ago, and it isn't now.

      --
      quidquid latine dictum sit altum videtur.
    26. Re:Love this quote by luzr · · Score: 1

      Well, that is one interpretation, but I believe this is not correct.

      Traditional CISC was using microcode and decoder that converted each CISC instruction into series of microcode operations.

      The cornerstone of RISC architecture is that you make microcode your "public" ISA - that avoids CPU decoder and performs all or most instructions is single cycle.

      Now see what modern CPU do: they convert input stream of "public" ISA instructions into internal microcode. Unlike old-time CISCs, they convert a couple of ISA instructions into single microcode instruction (while old CISCs converted single ISA instruction into many microcode instructions). Anyway, this is still closer to original CISC design than to RISC.

      If you would like to call internal microcode machine a RISC, ok, but keep in mind that those instructions are specifically designed for its purpose and could not be used as external ISA for any CPU (ok, transmeta excluded :).

      In other word, if your public ISA is not reduced and equivalent to microcode, it is not RISC CPU.

      And then, on top of that, there is PowerPC G5 that interprets RISC ISA as if it was CISC ISA :)

    27. Re:Love this quote by naasking · · Score: 3, Informative

      The biggest problem seems to be that that extra layer of abstraction slows things down (which makes sense really). [...] If heavy usage servers can be run as virtual machines in Xen then why not use a microkernel too?

      Funny you should mention Xen, because it's essentially a microkernel running other kernels as protected processes.

      So. Any examples of microkernel OS's that handle heavy server load, function well as a desktop, and can handle multimedia tasks like gaming?

      Other posts mention QNX, so I won't bother.

      I'd find it hard to believe that with solid numbers showing that microkernel is just as fast and without additional overhead that someone like Linus wouldn't use it since it's an easier programming model (better for security, stability, etc).

      You'd be surprised. There's a lot of vested interest in the current programming paradigms and existing codebase. A principled microkernel architecture might just be incompatible with POSIX, which eliminates a large swath of portable and useful software.

      If you want performance, you need look no further than L4, EROS (and it's successor CapROS). For a principled design, I'd go with EROS/CapROS or the next generation capability system Coyotos (who's designers are trying very hard to implement POSIX while maintaining capability security).

      Something useful right now, doesn't exist as far as I know.

    28. Re:Love this quote by luzr · · Score: 1

      Yes, because it is basically superscalar CISC design. RISC is not technical label anymore, just marketing thing.

    29. Re:Love this quote by ChrisDolan · · Score: 2, Informative

      Good point. Both OS X and NT+ do violate the microkernel philosophy in the name of performance (Wikipedia calls them Hybrid kernels). However, they differ significantly from monolithic kernels like Linux in that third party drivers are by default outside of the kernel instead of inside.

      So perhaps they're millikernels? :-)

    30. Re:Love this quote by Sentry21 · · Score: 4, Informative

      OS X uses BSD under a microkernel I think but my experience is that it is slow and the tests I've seen have shown that Linux performs a lot better on it than OS X (no idea if that was due to microkernel use).

      The OS X kernel is a different situation. Darwin is a mixture of microkernel and monolithic, as is (for example) Linux. In Linux, a lot of things (like device configuration, etc.) get done in userspace by daemons using a kernel interface, which means the kernel need only contain the code necessary to initialize the device. Darwin's kernel (xnu), however, is a more complex design in terms of overall design (though the internals may be less complex - I'm not a kernel developer), and is derived from Mach 3.0 and FreeBSD 5.0.

      Mach provides xnu with kernel threads, message-passing (for IPC), memory management (including protected memory and VM), kernel debugging, realtimeness, and console I/O. It also enables the use of the Mach-O binary format, which allows one binary to contain code for multiple architectures (e.g. x86 and PPC). In fact, when I installed OpenDarwin quite a while ago, all the binaries that came with it were dual-architecture-enabled, meaning I could mount the same drive on PPC or x86 and execute them (which is kind of neat).

      The BSD kernel provides (obviously) the BSD layer, as well as POSIX, the process model, security policies, UIDs, networking, VFS (with filesystem-independant journalling), permissions, SysV IPC, the crypto framework, and some primitives.

      On top of all that is IOKit, the driver framework. It uses a subset of C++, and the OO design allows faster development with less code, and easier debugging as well. It is multi-threaded, SMP-safe, and allows for hot-plugging and dynamic configuration, and most interestingly of all, some drivers can be written to run in userspace, providing stability in the case of a crash.

      Now, as to your comment about performance, it is possible you are referring to the tests done using MySQL a while back, which shows MySQL performance as being (as I recall) abysmal compared to Linux on the same hardware. The problem with that test is that MySQL uses functions that tell the kernel to flush writes to disk. These functions are supposed to block so that the program can't continue until the writes are done and the data is stored on the platter. On OS X, this is exactly what happens, and every time MySQL requests data be flushed, the thread doing the flushing has to wait until the data is on the platter (or at the very least, in the drive's write cache). On Linux, this function returns instantly, as Linux (apparently) assumes that hard drives and power supplies are infallible, and obviously if you're that concerned about your data, get a UPS.

      It should be noted that MySQL, in the online manual, strongly recommend turning that feature off for production systems, forcing Linux to block until the write is completed, and lowering performance. I would be interested to see a benchmark comparing the two with this configuration.

      This discrepancy in the way Linux handles flush requests vs. the way OS X handles them gives a noticable drop in performance in a standard MySQL situation. I am told that the version that ships with OS X Server 10.4 is modified so as to increase performance while keeping reliability. Unfortunately, I cannot confirm this at this point.

    31. Re:Love this quote by Anonymous Coward · · Score: 0
      I have some experience in this area and can comment on it. Basically, in a monolithic kernel, the process of developing many of the components is fairly well understood, the semantics are defined, it's done and we know how to do it.

      In microkernels, including mach and the L4 family, doing some fairly simple tasks, like writing a basic file system, are radically more difficult to accomplish (more so enough that it's not hardly done, or maybe there just isn't any interest, but I assert that doing it pure in uKernel is more difficult) so you look at OSX or the NT family and they really aren't microkernel at all, they are monolithic with some of the semantics defined by uKernels and some of the interfaces but that's about it. If we apply the RISC v. CISC logic; RISC won big time, so big that all the CISC processors now convert instructions in to RISC like microps internally and do RISC things. Monolithic kernels won out big time, so much so that all the practical microkernels use lot's of monolithic kernel features.

      It's a great concept, it "makes the kernel more simple" which in theory allows for it to be more robust, etc.. The reality is that it pushes a trememdous amount of complexity out a ring and those components then tend to lack the the reliability. Unfortunately, many of those components are generally required when we think of an OS. Lot of good a working scheduler is going to do you when you cannot access a filesystem because that server has crashed. Or maybe your serial IO has gone down.

      As an aside, in the days of OS/2 I heard it explained once how the single input queue which could lock up the whole UI wasn't a problem because the actual kernel was still running. So while you couldn't interact with the system at the console and it had no real remote managment, it was still servicing interrupts and thus the system hadn't really crashed. The same logic applies to the microkernel, the better defined it is and the more "micro" it is the more likely that it'll be difficult to implement some components that the system depends on to be usable in userspace and they will fail leaving a non-crashed but non-functional system.

      Maybe in the old days, it made sense, today, I think we have a pretty good grasp of memory and task managment concepts. All modern kernels are modular while very few are purely microkernel and the concepts that microkernels tend to abstract out are almost trivial that it doesn't buy you much to abstract them out that way. Modularize your kernel to have clean interfaces, you can use taskgates to have a degree of fault control, you still have to do the harder parts like all the device I/O and that's the part that is going to break anyways.

    32. Re:Love this quote by RAMMS+EIN · · Score: 1

      ``Your kidding right? Modules != micokernel.''

      You're right, but modules provide many of the benefits of a microkernel. You can load and unload them separately from the rest of the kernel, just like with a microkernel. You can compile them separately from the rest of the kernel, just like with a microkernel. These things are not possible with a purely monolithic kernel, and Linux would probably not has come so far so fast if it had been purely monolithic.

      --
      Please correct me if I got my facts wrong.
    33. Re:Love this quote by pthisis · · Score: 1

      The problem with that test is that MySQL uses functions that tell the kernel to flush writes to disk. These functions are supposed to block so that the program can't continue until the writes are done and the data is stored on the platter. On OS X, this is exactly what happens, and every time MySQL requests data be flushed, the thread doing the flushing has to wait until the data is on the platter (or at the very least, in the drive's write cache). On Linux, this function returns instantly, as Linux (apparently) assumes that hard drives and power supplies are infallible, and obviously if you're that concerned about your data, get a UPS.

      This is not true. The only time Linux returns after an fsync (or fdatasync) without the data being physically on disk is when the device lies about the write being complete. MacOS also returns immediately in that case. The problem is not an OS problem, it's that a lot of IDE drives for the PC come shipped with write caching enabled.

      --
      rage, rage against the dying of the light
    34. Re:Love this quote by iabervon · · Score: 2, Interesting

      It turns out that, in order to get good RISC performance, you need to design a new architecture every few revisions. The RISC instruction set that the P4 uses is different from the P3, which is different from the P2, and so forth. The benefit of the way Intel does things is that, since they're emulating a CISC instruction set on a RISC core, they can switch to emulating the same CISC instruction set on a better RISC core, and nobody has to be told about the new architecture. The translation layer can optimize the input for the chip it's running on, and take advantage of things like how many registers the chip actually has and how many branch delay slots it uses. And it turns out to be easier to translate CISC into RISC than RISC into other RISC, because you've got a better idea of what the code is actually doing.

    35. Re:Love this quote by MikeFM · · Score: 1

      OS X does not perform well. You can feel it when using it and testing seems to agree. Also it crashes fairly often. I am actually shocked at how often I've seen different OS X machines crash. I'd dare to say they crash at least as often as XP in my experience.

      NT, 2000, and XP don't perform well either and aren't very stable (better than Win9x but that isn't much). Hardly anything I'd brag about.

      Just about any code can be ran on top of a microkernel - that's sort of the point of a kernel isn't it? BSD and Linux can certainly run on top of it but they don't run as well when they are ran that way.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    36. Re:Love this quote by MikeFM · · Score: 1

      It sucked last time I tried it but that was a long time ago. Everything sucked back then. I'll give it another peek. Do they still have a free demo version? I glanced at their web page and I didn't see it.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    37. Re:Love this quote by Olivier+Galibert · · Score: 1

      Nope, CISC is technically superior for current processors because it allows to pack more instructions in less bytes. And it looks like nowadays a CISC-RISC translator takes less silicon than a bigger L1/L2. Don't underestimate the packing effect of CISC instruction sets, especially vs. RISC-VLIW. That's part of what killed IA-64.

      The ability to change the underlying RISC/microcode without changing the CISC front-end is not to be neglected either.

          OG.

    38. Re:Love this quote by po8 · · Score: 2, Informative

      Cheriton's V System didn't suck. I used it in a commercial project in the late 1980s and loved it; it met all of your criteria. If Cheriton had open-sourced it, I think it would have had a huge impact. But he didn't, and for whatever reason it hasn't.

    39. Re:Love this quote by Olivier+Galibert · · Score: 1

      But linux _is_ purely monolithic. There is only one address space, and modules link their symbols directly inside the current image. Modules are equivalent to dlopen(), not fork+exec(). There is also no communication interfaces per se. Modules directly call functions or access structures fields. Of course these functions and structures are (mostly) organized in APIs and semi-objects, but that means the internal design is clean, not that it has anything to do with a microkernel.

          OG.

    40. Re:Love this quote by MikeFM · · Score: 1

      Cool, I'll check them out. I can see that it's good to stick to POSIX unless there is an even better reason to break POSIX compliance. What about the microkernel breaks POSIX? Not really sure what capability security is.. and I'm sure a lot of people are even less sure than I am. ;)

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    41. Re:Love this quote by bfields · · Score: 1
      Also, Linux isn't a pure monolithic kernel. Almost everything is loaded as a module these days, and modules can communicate through message passing, and can even be implemented is userspace in some cases (e.g. filesystem drivers with FUSE). Even the direct function calling that modules do can be seen as just an optimization of what MINIX does with message passing.

      A microkernel runs in a separate address space--that's why it is can't be brought down by driver bugs. Modules don't have that property--they're just bits of code that are loaded dynamically but have rights to all the same stuff as any other bit of kernel code. So modules aren't microkernel-like, but FUSE filesystems (which run in user space--they aren't kernel modules) arguably are.

    42. Re:Love this quote by dvdeug · · Score: 1

      Not at all! The Pentium Pro doesn't emulate the x86 instructions in software. It "emulates" them in firmware; no program running on the Pentium Pro can tell that there's emulating going on. It made no difference to the OS writer; it offers the same interface to write to.

    43. Re:Love this quote by AKAImBatman · · Score: 1

      What you say might be correct, except that the primary chips that were considered CISC (8086-80286) did not, to the best of my knowledge, make use of microcode logic. (This was also true of the Z-80 and many other CISC chips.) As I understand it, the Intel line used Random Logic all the way through the 286 chip.

      The key difference between a RISC and a CISC chip was always that a RISC chip executed a single instruction per cycle, whereas a CISC chip could take more than one cycle per instruction. To the best of my understanding, this paradigm was at the silicon level, NOT the microcode level. In fact, a "pure" RISC design wouldn't have microcode at all, as such code is the anti-thesis of "one instruction per cycle". Instead, it's up to the compiler to generate more complex sets of instructions to make up for the lack of microcode. This gives the compiler an opportunity to reorganize the instructions to ensure maximum utilization of the superscalar silicon. (Note: This may be as simple as expanding the instructions one way, or as complex as Out-Of-Order Execution.)

      Today, pretty much all experts agree that the terms RISC and CISC are meaningless. Most processors use a pipelined design that executes one pipeline stage per clock cycle. This gives an effective execution speed of one cycle per instruction, but a rather large latency consistent with the pipeline length. Microcode may then be used to translate formerly CISC or RISC instructions to real processor instructions. In CISC instruction sets, this means that multiple real instructions may execute for each microcode instruction executed.

      Let's not even get started on SIMD changes the playfield altogether.

    44. Re:Love this quote by MikeFM · · Score: 1

      I've ran a lot of different programs on Macs under both OS X and Linux and Linux certainly runs faster. I don't think it's just MySQL although that is the study I was referencing. I don't think there is anything wrong with the Mac hardware but something seems seriously wrong with OS X when it comes to speed and reliability. I saw OS X crash often on several different Macs (totally different models) and they were just slow especially when it came to using the network and file access. Transfering large files between two Macs over the network was slow and painful regardless of the program used. Windows has a similar problem - transfering the exact same file is MUCH faster under Linux. I transfer a lot of files under all the OS's so I've had a lot of experience in how long it takes. Literally I can transfer 5GB of files between two Linux boxes in the time it takes to move 500MB of files between Mac or Windows boxes.

      I haven't tried Tiger yet. I heard it fixed some of those problems?

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    45. Re:Love this quote by MikeFM · · Score: 1

      Sadly licensing often plays that role. Things that should have changed computing didn't because people didn't want to give up the keys.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    46. Re:Love this quote by wilsone8 · · Score: 1

      Um, You will have to pardon my ignorance here, but since when have device drivers ever been outside of the kernel in a Windows OS? At least in NT 4.0 and beyond (I'm too young to know any earlier), they always run in kernel space as far as I know.

      --
      The real problem is not whether machines think but whether men do. - B.F. Skinner
    47. Re:Love this quote by Anonymous Coward · · Score: 0

      More like intel's chip designers couldn't design a decent ISA if their life depended on it. Witness the mess of mmx/mmx2/sse/sse2/sse3. This guys whip out half assed ISA's like toilet paper...

      POWER has scaled nicely for years, and has survived the transition to 64-bit with virtually zero changes to the ISA. If Intel actually put some work into designing robust ISA's they might find those designs last more then one generation.

    48. Re:Love this quote by dloose · · Score: 1

      Saying things like "Literally I can transfer 5GB of files between two Linux boxes in the time it takes to move 500MB of files between Mac or Windows" smacks of fanboyism. You're going to have to offer up something other than anecdotal evidence at some point.

    49. Re:Love this quote by Samrobb · · Score: 2, Interesting
      Still.. as fast as modern computers are I think we may be reaching a point where raw speed is less important and well designed microkernels can probably run almost as fast as monolithic kernels.
      I'm surprised nobody's mentioned this yet... there was an article in the latest C/C++ User's Journal titled Interprocess Communication & the L4 Microkernel. Made for interesting reading. The main idea seems to be that traditional microkernel designs spend too much time and effort having the kernel validate messages.
      --
      "Great men are not always wise: neither do the aged understand judgement." Job 32:9
    50. Re:Love this quote by operagost · · Score: 1

      Then what the heck are these? Being as HP is betting its entire line on Itanium (OpenVMS, HP/UX, and Windows), failure would probably require a collapse of the entire industry (or cause it).

      --

      Gamingmuseum.com: Give your 3D accelerator a rest.
    51. Re:Love this quote by Kadin2048 · · Score: 1

      What were you doing that crashed OS X?

      I'm genuinely curious -- I use an OS X box at home (an old 400MHz one, still runs the latest system) and it handles everything I throw at it in terms of average tasks while still remaining rock solid. In all honesty if you told me to do something right now that would make the machine crash, I'm not sure what I'd be able to do.

      The only times I've been able to throw a wrench in it were when I've been playing with really buggy pre-beta software. Using regular production apps I can't remember the last time I took the OS down.

      If your system was seriously as unstable as you say, I'd seriously question whether there might have been some sort of hardware failure (bad RAM?) going on. OS X is by no means a speed demon (those tests of DB performance just confirmed what I'd always suspected), but that's the first time I've heard someone who's comments I otherwise agreed with call it unstable.

      --
      "Ladies and gentlemen, my killbot features Lotus Notes and a machine gun. It is the finest available."
    52. Re:Love this quote by operagost · · Score: 1

      No. The video subsystem does, but neither the video hardware drivers nor any other drivers run there.

      --

      Gamingmuseum.com: Give your 3D accelerator a rest.
    53. Re:Love this quote by justins · · Score: 1

      Not at all. Remember, he specified the operating systems which are designed. Most simply accrete.

      --
      Now before I get modded down, I be to remind whoever might read this that what I am saying is FACT. - bogaboga
    54. Re:Love this quote by Watts+Martin · · Score: 1

      While I haven't done much -- well, okay, any -- formal testing, I've been running OS X on various Macs since the 10.1 release and it's mostly been quite stable. Possibly less so than Linux and FreeBSD boxes (Intel) that I've run in the past, but the OS X box sometimes suffers with buggy third-party extensions I've subject it to.

      I really haven't compared OS X to Linux on the same hardware, other than a Live CD version of Ubuntu (which was glacially slow, but running from a CD does that). OS X does seem to be subjectively a bit "sluggish" in some operations for a Unix, but I don't know how much of that -- like your example of file transfer speed -- can really be blamed on the kernel.

      FYI, in my experience, Tiger has been the least stable 10.x release since 10.1. This isn't to say that it's been crashing all the time, but I can't recall ever once having a kernel panic under 10.2 and 10.3, and I've had two under 10.4.

    55. Re:Love this quote by Touisteur · · Score: 0

      QNX is even better than that. It's a -RealTime- -Microkernel-

      It is very fast, lightweight and somewhat convenient to use.

      It respects POSIX (IIRC they're the most posix-compliant OS), is certified by "some military " (don't have the exact name of the certification), and is kind of fun to develop on/with.

      My favorite feature, made "easily" possible by their microkernel-message-passing architecture : a network of QNX machines appears as an only machine. Clustering is very straight-forward, resource sharing is automatic. And it's build over IP, so it's routable. Many "mainstream" applications are ported to QNX (PostgreSQL, Apache-php, Gnat...) and QSSL (the company that develop QNX) is the official maintainer of CDT, the C/C++ plug-in for Eclipse. So QNX also supports Java.

      BUT, QNX is awfully expensive, and closed-source...

      The point ? It is proved that a microkernel architecture IS viable, can scale very well and can be über fast =o).

      So, AST was/is right. GO GO GNU !

    56. Re:Love this quote by DrXym · · Score: 1
      I grant you that it sucked during the days of QNX 2. I used to have to program it and while it was very fast, and very modular the code for it was godawful, the tools were obscure and the UI was modelled on OpenLook of all things. The per seat licencing was a joke too, being more expensive that Windows or OS/2. It was horrible yet for all that there was absolutely nothing to touch it. Linux was still at 1.0x and Windows was non-preemptive.

      With QNX 4 up, they dumped the proprietary APIs and tools and made the thing POSIX compliant. At that point, it's hard to fault it. It's just another Unix clone from a programming perspective. While I wouldn't say for a second that it's comparable to Linux for its desktop experience (though neither is BSD), it is very, very compact and stable. I know there was a live CD at one point but at present it seems to be a 30 day trial version. I guess that's as close as you'll get. At one point, they had a version which booted from a single floppy disk and offered networking, a GUI and webbrowser. That's a stunningly compact OS, no matter how you look at it.

      It still doesn't answer the debate about micro vs monolithic kernels, but it does dispell the idea that you can't produce a decent OS around a micro-kernel. Personally I think monolithic is just fine except for niches but given the right requirements, micro can work out to be a lot better. I certainly don't believe GNU Hurd is a good example of a microkernel even without the politics and lethargy that have caused it to become a running joke over its grossly extended life.

    57. Re:Love this quote by nathanh · · Score: 1
      I think it was QNX that had one feature I did find interesting though.. the ability to move your logged in GUI session from client machine to client machine without shutting apps down or logging out. It was a pretty cool feature similar to what we can do with VNC today but smoother. I'd love to see that work in X. (If that wasn't QNX then I have no idea what it was!)

      http://packages.debian.org/unstable/x11/teleport

    58. Re:Love this quote by Anonymous Coward · · Score: 0

      Another good example is Tru64.

    59. Re:Love this quote by wilsone8 · · Score: 1

      Wait a sec. Are you saying that drivers run in a user mode process? Cause that is just plain wrong. Drivers run in kernel space. Hence why they have to handle things like non-paged memory, disabling interrupts, etc, etc.

      --
      The real problem is not whether machines think but whether men do. - B.F. Skinner
    60. Re:Love this quote by Anonymous Coward · · Score: 0

      Err, no, wrong. It has fixed length instructions and a load store ISA. POWER is as RISC as you get.

      Not to mention that it comes with all the apparent downsides you mentioned, like code size being roughly double that of i386 code.

      You're wrong.

    61. Re:Love this quote by T-Ranger · · Score: 2, Insightful

      Your little case study of Intel only proves that Intel is incapable of creating a long-term-worthy CPU core. And that might not even be true ... The Pentium M is built on the line of P-Pro/P3, not the all-new P4. I dont think that there is a sufficently large pool of modern RISC processors around that one can make any general statements on the R&D cycle of RISC processors.

      What could be stated is that by having a CISC-on-RISC processor one can persue multipe RISC cores and allow them to flourish, die, and be revived on entirely unpredictable market demands, and long term developement costs of a paticular core. This isnt unique to CPU design, nor is it a new concept. Brooks covers multiple implementations in Mythical Man-Month.. Virtual machines be it software ala Java, Smalltalk, Lisp, or the virtual-to-the-exteeem AS/400 platform.

      No new lessons to be learnt here.

    62. Re:Love this quote by johansalk · · Score: 2, Insightful

      Coca Cola is far more popular than much healthier drinks. The marketplace is governed by economic and political considerations that should not mean what fails it is inferior.

    63. Re:Love this quote by Anonymous Coward · · Score: 0

      Does anyone else read CapROS as CrapOS?

    64. Re:Love this quote by naasking · · Score: 1

      Does anyone else read CapROS as CrapOS?

      Perhaps that should be the motto huh? "All OSes are crap. CapROS: less crappy than the rest." ;-)

  4. Honest question by Frogbert · · Score: 4, Interesting

    Honest question, is Minix compatable with Linux or something? Or do they just sound the same by coincidence? Or is it more like your BSD's in comparision to Linux?

    1. Re:Honest question by gpierre · · Score: 1
      > Honest question, is Minix compatable with Linux or something? Or do they just sound the same by coincidence? Or is it more like your BSD's in comparision to Linux?

      Actually, Minix and Linux are derivatives of Unix, which explains why both names sound similar to Unix.

    2. Re:Honest question by nmoog · · Score: 1

      Its hardly a coincidence they sound the same! Linus made Linux as a free version of Mininx! Dunno how compatible they are anymore though...

    3. Re:Honest question by g0sub · · Score: 0, Redundant

      Minix was (is) an operating system designed to be used for educational purposes. In addition Tannenbaum uses it to prove his point about mikrokernels. Torvalds got the idea of making your own unix from having used minix.

    4. Re:Honest question by TheMMaster · · Score: 5, Interesting

      more like your BSD's in comparision to Linux :)

      all three are more or less posix compliant operating systems, which means that most software should run on both.

      Some software that requires some functionality not found in posix will need to be ported sperately. Like xorg for instance, but, most of the gnu tools will probably run (probably) and there is the question what c library it uses, if it uses its own, there are going to be a whole myrad of other interesting problems, if it uses glibc or bsd's libc, then it's easier.

      in other words :"more like your BSD's in comparision to Linux"

      --
      Fighting for peace is like fucking for virginity
    5. Re:Honest question by shadowknot · · Score: 5, Informative

      Linus Torvalds was kind of inspired by minix to create a more useable and extensible Open Source OS and the original source for the Linux Kernel was written using a minix install. Check out the DVD of RevolutionOS for a detailed history.

    6. Re:Honest question by dAzED1 · · Score: 1, Interesting

      Check out some history of Andy and Linus.

      No, Minix doesn't just happen to sound like Linux, or vice-versa. They both intentionally sound something like "UNIX" ;)

      Linus was Andy's student a long while back. Andy taught (and still teaches? I think) "modern operating systems," and Linus was summarily unimpressed with Minix. Linus had a terminal prog he had written, this and that happened, and tada! Linux was born.

      Andy and Linus, as far my understanding goes, don't like each other much. I haven't read anything on their relationship in years though.

    7. Re:Honest question by /ASCII · · Score: 5, Informative

      Linus was never Tannenbaums student. They met online in a classic flamewar where Tannenbaum delivered such classic comments as 'If you where my student, you wouldn't get a very high grade'. But Linux was born out of gripes Linus had with Minix.

      --
      Try out fish, the friendly interactive shell.
    8. Re:Honest question by strider44 · · Score: 1

      It's hardly a coincidence, as they both branch off the Unix standard.

    9. Re:Honest question by Anonymous Coward · · Score: 3, Funny

      Could you please forward the contact information for this Andy Tanenbaum person to me at the address below. I would like to have a word with him. Thanks.

      355 South 520 West
      Suite 100
      Lindon, UT 84042

    10. Re:Honest question by nova20 · · Score: 1

      Linus Torvalds was inspired by a unix distro named Minix when he wrote Linux. Is it possible that it's the same OS now, it's just been revived and gotten more popularity?

      My eyes almost popped out of my skull when I saw "Minix" and "new OS" in the same sentence. Is the same OS from the late 60's, or am I thinking of something else?

    11. Re:Honest question by leuk_he · · Score: 2, Informative

      GNU/Linux is somehow compatible with minux.

      They both run most of the gnu toolset. Note that minux has more of a bsd like license. "Redistributions in binary form must reproduce the above copyright notice...". Note that the minux distirbution contains a lot of the (GPL) gnu tool.

    12. Re:Honest question by dAzED1 · · Score: 1

      ah yes, that's right...well, it's been years since I cared. All seemed a bit silly to me, even if it did have great results.

      But in the end, the answer is "coincidence," as they are both independently trying to sound like UNIX.

    13. Re:Honest question by TDRighteo · · Score: 5, Informative

      Ah, no, Linus was definately not Tanenbaum's student. Quite aside from the fact that Tanenbaum taught in the Netherlands and Linus studied in Finland, we couldn't have this quote if he was:

      I still maintain the point that designing a monolithic kernel in 1991 is a fundamental error. Be thankful you are not my student. You would not get a high grade for such a design :-)
      --- Andy Tanenbaum

      However, Linus did admit that at least one academic from his own university shared Tanenbaum's opinions, and thus he was unlikely to be getting high marks anyway. ;-)

      As has been pointed to before, you can find an abstract of the famous "Linus vs Tanenbaum" posts to comp.os.minix here.

    14. Re:Honest question by kspiteri · · Score: 1

      Linus was never Tannenbaums student.

      Still, Linus learned a lot from Tanenbaum's book on operating systems.

    15. Re:Honest question by Anonymous Coward · · Score: 0
      Linus did admit that at least one academic from his own university shared Tanenbaum's opinions, and thus he was unlikely to be getting high marks anyway.

      Linus cried all the way to the bank, I expect. I won't go so far as to say that "academic approval" and "industry success" are mutually exclusive, but they sure as hell don't look related.

    16. Re:Honest question by Anonymous Coward · · Score: 0

      "Be thankful you are not my student. You would not get a high grade for such a design :-)"

      That's a joke, but it's still interesting. I think that any professor would be happy to have had a student like Linus Torvalds. How many students actually do something during their free time instead of (insert here whatever you did when you were a student)...not to mention change the world and all that crap.

    17. Re:Honest question by platypus · · Score: 1

      Slightly offtopic, but I stumbled over something on this site and that leads to a plea:

      Could someone please have a look at the
      "The Free Software Song" music video and tell me if it's save to watch?
      Subtext:

      "The Free Software Song" is performed by the office park band, The GNU/Stallmans.
      The lyrics are by Richard Stallman. The music video is a three minute-long, 28 mb MPEG file.


      I don't dare to.

      Many thanks.

    18. Re:Honest question by multipartmixed · · Score: 1

      You're thinking of Multics, which predates Unix.

      --

      Do daemons dream of electric sleep()?
    19. Re:Honest question by jtshaw · · Score: 2, Insightful

      If you read Linus' book he basically says he started writing Linux because he thought Minix was terrible. That is why Linux original used ext2 (same fs as minix). So in reality, Minix and they have similar sounding names because they are both trying to be like unix.

    20. Re:Honest question by arkane1234 · · Score: 2, Informative

      That is why Linux original used ext2 (same fs as minix)

      No, Minix used (uses? not sure what the "new" minix uses) the minix filesystem, which was only able to address I think it was 32mb of space.
      Linux had the EXT2 filesystem at a later date, migrating away from the Minix filesystem. If you compile your kernel, you'll still see the option to have the minix filesystem functionality compiled in. (or modularized)

      I still remember having to decide if I wanted to go with the "new" ext2 filesystem, which will not be compatible with older kernels. *g* Back then, that was a big deal, or so it seemed.

      Btw, saying that Minix and Linux are "trying" to be like Unix is about like saying that Hyundai and Acura are alot like Toyota because they are trying to be cars.

      --
      -- This space for lease, low setup fee, inquire within!
    21. Re:Honest question by Anonymous Coward · · Score: 0
      I haven't looked at this particular link, but the song exists.

      And, I assure you that you don't really want to see or hear it.

    22. Re:Honest question by Frankie70 · · Score: 1

      Honest question, is Minix compatable with Linux or something? Or do they just sound the same by coincidence?

      They sound similiar because both the names are derived from Unix.

      Check here for a famous 1992 flamewar between Linus Torvalds(creator of Linux) & Tanenbaum(creator of Minix).

      Minix came before Linux.

    23. Re:Honest question by gmack · · Score: 1

      More accurately Linux and Minix follow the unix standard. Derivitive implies they were started from the Unix codebase. Neither were, and that won't change no matter how many of SCO's blatherings to the press and court scream the opposite.

    24. Re:Honest question by shadowknot · · Score: 1

      It's safe to watch if you like that kind of thing but it's really badly recorded audio and personally (and of course everyone's diffenent) I think it sucks harder than a supergiant black hole! IMO of course, please don't flame me!

    25. Re:Honest question by Anonymous Coward · · Score: 0

      Didn't you hear! Linus stole minix code to write Linux!!! Yeah! Just ask that McBride guy. Linus steals everything! :P

    26. Re:Honest question by Anonymous Coward · · Score: 1, Funny

      "I've been waiting for you, Tannen-Baum. We meet again, at last. The circle is now complete. When I met you I was but the learner. Now, *I* am the master."

    27. Re:Honest question by boisepunk · · Score: 1

      You're thinking of SCO/UNIX, which predates all other UNIX rights.

      --
      main(0)
    28. Re:Honest question by Anonymous Coward · · Score: 0
      No, I recall that Linus said he didn't agree with Minix' original licensing -- which was for educational use only, ie, no commercial use. He wanted more freedom than that, and wanted to learn more about his new '386 and about OS, so he began the linux kernal.

      btw, this makes for an interesting comeback to the few who still say Linux and related works are deliberately anti-commercial: the kernal was only begun to have more freedoms than Minix' non-commercial-only license would allow.

      (Just a couple years ago, Minix went over to a BSD-license anyway.)

    29. Re:Honest question by nathanh · · Score: 1
      That is why Linux original used ext2 (same fs as minix).

      Minix did not use ext2. Even the original Linux did not use ext2. The original Linux used minixfs, then later moved to extfs, then later again to ext2fs, and later again to ext3fs.

  5. About Tannenbaum. by Anonymous Coward · · Score: 3, Informative

    Tannenbaum's home page:

    http://www.cs.vu.nl/~ast/

    Yes, it's the same guy who wrote the book for your networking course.

    1. Re:About Tannenbaum. by jedZ · · Score: 1

      Don't forget to check out the Steganography demo (link at bottom of page)

    2. Re:About Tannenbaum. by Jonny_eh · · Score: 1

      and your OS course.
      Not to mention he was the mystery man behind electoral-vote.com last year.

  6. Thank you, Dr. Tanenbaum. by CyricZ · · Score: 3, Insightful

    I just want to thank you, Andy, for your decades of effort towards advancing the field of computing. Your contributions have been much appreciated. After all, if it were not for Minix we would not have Linux today. Thanks, Andy!

    --
    Cyric Zndovzny at your service.
    1. Re:Thank you, Dr. Tanenbaum. by TrappedByMyself · · Score: 4, Funny

      Your contributions have been much appreciated.

      Yes, thank you. My sadistic operating systems professor used your textbook. Your name still gives me nightmares to this day.

      --

      Help me take back Slashdot. When did 'News for Nerds' become 'FUD and Conspiracy Theories for Extremist Nutjobs'?
    2. Re:Thank you, Dr. Tanenbaum. by Anonymous Coward · · Score: 0

      Isn't quite right to give all the credit to Andrew. The efforts of Linus and the GNU project should not be underestimated.

    3. Re:Thank you, Dr. Tanenbaum. by E1ven · · Score: 2, Interesting

      He also deserves praise for his work on the 2004 Election. He updated a map every day, using poll data from a number of sources, and mapping it against the electoral values of each state.
      It was a tremendous site, and I look forward to his coverage of the 2006 Senate.

      --
      Colin Davis
    4. Re:Thank you, Dr. Tanenbaum. by Anonymous Coward · · Score: 0

      "After all, if it were not for Minix we would not have Linux today."

      That's quite possibly true.

      It does annoy me though that people aren't as generous with crediting Stallman in a similar manner.

    5. Re:Thank you, Dr. Tanenbaum. by MichaelSmith · · Score: 1
      After all, if it were not for Minix we would not have Linux today

      If Minix had not been so hard to reinstall, Linus Torvalds might not have written his own operating system.

    6. Re:Thank you, Dr. Tanenbaum. by Anonymous Coward · · Score: 1, Funny

      Richard, is that you?

    7. Re:Thank you, Dr. Tanenbaum. by MikeFM · · Score: 3, Insightful

      That's okay. My experience has been that RMS is never shy to give himself credit.

      I really appreciate and love the FSF, GPL, free software, and GNU tools but I'm never going to call Linux GNU/Linux. Let him put his adverts on his own damn stuff rather than trying to convince everyone else to do so. Just because my car sits on a foundation of Goodyear tires doesn't mean I'm going to call it a Goodyear/Focus. Sure that might sound like a new years resolution but it's still dumb and a nightmare in product advertising. I'd be shocked to see Ford advertising it that way.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    8. Re:Thank you, Dr. Tanenbaum. by Anonymous Coward · · Score: 0

      "...Just because my car sits on a foundation of Goodyear tires doesn't mean I'm going to call it a Goodyear/Focus..."

      *sigh*

      Let the flames begin!

    9. Re:Thank you, Dr. Tanenbaum. by TheRealMindChild · · Score: 1

      But your Goodyear tires don't comprise 95% of your vehicle... there is the difference

      --

      "When life gives you lemons, don't make lemonade. Make life take the lemons back!" -- Cave Johnson
    10. Re:Thank you, Dr. Tanenbaum. by richie2000 · · Score: 1

      *fade in the chorus of "Oh, Tanenbaum"*

      --
      Money for nothing, pix for free
    11. Re:Thank you, Dr. Tanenbaum. by Anonymous Coward · · Score: 0

      And the GNU utilities do not make up 95% of the utilities.

      Hint: X isnt GNU. And alot of other software on a typical Linux distro are not GPL'd. And much of the software that uses the GPL are not part of the GNU project.

    12. Re:Thank you, Dr. Tanenbaum. by MegaFur · · Score: 1

      But does GNU software really comprise 95% of Linux?

      (here I intentionally parrot something Linus said once) The major contribution of GNU to Linux, as I see it, is the compiler, and the GNU license itself.

      If you're going to give credit to all major Linux components, then surely you'd have to credit X Windows as well. So now it's X/GNU/Linux. And then, really, since the desktop layer is so large, you should credit it too. Now it's {Gnome,KDE}/X/GNU/Linux.

      And now, as we go along the name of your specific Linux system will become increasingly different from everyone elses as we list all the specific major software components that make your system what it is. This gets pedantic and tedious pretty fast. As a parent poster said, I think RMS is plenty good at making sure he and his get credit where it's due already.

      --
      Furry cows moo and decompress.
    13. Re:Thank you, Dr. Tanenbaum. by pzs · · Score: 1

      We also wouldn't have that quality quote about bandwidth, one of the only things I remember (explicitly) from my undergraduate networking course:

      "Never underestimate the bandwidth of a station wagon full of tapes hurtling down the highway".

      Peter

    14. Re:Thank you, Dr. Tanenbaum. by MikeFM · · Score: 1

      Certainly my Linux system isn't made of 95% of GNU programs and a lot of the programs distributed by the GNU project were not written by the GNU project but were donated to the GNU project. I was considering donating some of my projects to GNU before RMS went on his ranting but that was enough to decide me that I didn't want to fuel him. It's an utter waste of time to be going around telling other people to change their names.

      Even if 100% of my car were made by Goodyear that doesn't mean the distributor needs to call it Goodyear/Focus. Case in point - the new Ford hybrid SUVs are based largely on technology licensed from Honda. Are they calling them Honda SUVs or Honda/Ford SUVs? Of course not. They're still Ford.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    15. Re:Thank you, Dr. Tanenbaum. by tchuladdiass · · Score: 2, Interesting

      Actually, your analogy works perfect for this. Your Ford Hybrid is comprised of muliple components, but the main part that people see and feel is made by Ford, so it is a Ford, even though the kernel (hybrid drivetrain) is Honda.
      In the case of a typical Linux-kernel based distribution, the bulk of what you interact with (if you take out the GUI), i.e., the part that people see and feel (bash, cp, ls, gcc, emacs (ducks) is all GNU.
      Of course, I've left out anything related to the GUI above. To the old-timers, the GUI is nothing more than the equivilant of leather seats in your hybrid suv, but to others it is the equivalant to the Shelby modifications on a 67 Ford Mustang.
      Where am I going with this? Well, I think a Linux system should actually be refered to by the name of the distribution, i.e., you have a Red Hat OS, a Debian system, etc. There is a lot more that goes into putting together a distribution than just throwing together a kernel and a bunch of utilities. The only thing that should actually be called a GNU or GNU/Linux system is a distribution assembled and published by the GNU folks themselves.

    16. Re:Thank you, Dr. Tanenbaum. by Thud457 · · Score: 1
      "After all, if it were not for Minix we would not have Linux today." That's quite possibly true. It does annoy me though that people aren't as generous with crediting Stallman in a similar manner.

      Tanenbaum was the grain of sand, Linus the oyster.
      Ok, maybe it's a little overboard likening Linux to a pearl, but you get the idea. Andy's just irritating. :-p

      --

      the preceding comment is my own and in no way reflects the opinion of the Joint Chiefs of Staff

    17. Re:Thank you, Dr. Tanenbaum. by Anonymous Coward · · Score: 0

      ...and now every other reader see's why /. has such a bad image (like gentoo). 's/mod points/revenge of high school nerd/g' ...you really need to find some peace in your life.

    18. Re:Thank you, Dr. Tanenbaum. by petermgreen · · Score: 1

      Where am I going with this? Well, I think a Linux system should actually be refered to by the name of the distribution, i.e., you have a Red Hat OS, a Debian system, etc. There is a lot more that goes into putting together a distribution than just throwing together a kernel and a bunch of utilities. The only thing that should actually be called a GNU or GNU/Linux system is a distribution assembled and published by the GNU folks themselves.

      thing is we need a way to talk about linux systems in general as they share a lot of attributes. The basic C abi is the same for all linux systems on a particular CPU architecture as is the syscall interface into the kernel used by staticlly linked applications and the standard libraries come from the same upstream sources (though they may be different versions). Ok there are some compatibility problems caused by library devs who only care about compatibility in one direction (e.g. if i build a GTK app on a system with GTK 2.4 it probablly won't run on a system with GTK 2.2 even if the app doesn't use any of the new features from GTK 2.2)

      --
      note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
    19. Re:Thank you, Dr. Tanenbaum. by TheRaven64 · · Score: 1
      The basic C abi is the same for all linux systems on a particular CPU architecture

      Not true. The basic C ABI is provided by glibc - the g stands for GNU, by the way - in most distributions, however glibc is not always compatible across versions. Some smaller Linux distros use things like uClibc instead. I vaguely remember seeing one that used a BSD libc as well.

      as is the syscall interface into the kernel

      The syscall interface is provided by Linux, so it will be the same on all Linux systems (barring version incompatibilities). This is not unique to Linux, however. Other systems, such as FreeBSD, provide Linux-compatible syscall vectors to allow Linux binaries to run.

      Creating a system that is indistinguishable by a normal user from a `normal' Linux distro without Linux is a whole lot easier than creating one without GNU.

      --
      I am TheRaven on Soylent News
    20. Re:Thank you, Dr. Tanenbaum. by petermgreen · · Score: 1

      by basic C abi i mean choices like sizeof(int) sizeof(long) sizeof(long long) calling conventions etc that really have to be the same if you wan't any chance of linking with a lib. Yes there are alternative libcs availible which probablly have different prototypes etc for the stanrd functions and indeed you can install them in paralell if you so wish.

      i was more responding to the comment that we should just use distro names i don't really have a strong position either way on the linux or GNU/linux issue (though i do think stallman is a prick for never letting it drop).

      yes you can run linux binaries on freebsd and they mostly run its the little differences between two different implementations that get you (and generally in forms that are almost impossible to debug like your event loop hanging with 100% cpu after many days of running under load with no obvious cause). This is especailly bad with apps that use older syscalls (such as any app built with freepascal 1.0.x).

      As for glibc compatibility accross versions yes it suffers from the same problem as other linux libs: coders who only care about compatibility in one direction but theese problems can be worked arround either by using special tools or by building your binaries on the oldest distro you expect your users to use.

      --
      note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
    21. Re:Thank you, Dr. Tanenbaum. by Billly+Gates · · Score: 1

      I was a big fan of his 2004 election blog (www.electoralvote.org??). I used it daily behind slashdot during the campaign last year and had no idea Tanenbaum was behind it.

      Cnn always had links to this mysterious site which studies how the election was going mathmatically and what things meant politically.

      I thought he was a jerk from reading the flamewar comments to Linus but my views changed after it was revealed that Tanenbaum was the author.

      Anyway I like Tanenbaum and respect more and more. I hope he puts his site back up next year for the local elections.

    22. Re:Thank you, Dr. Tanenbaum. by dbIII · · Score: 1
      But your Goodyear tires don't comprise 95% of your vehicle... there is the difference
      OK then, lets call it OpenGroup/Linux, since xorg would provide the majority of lines of code in a distro and a lot of those would be left over from the Open Group reference implementation of X windows (hence the "make world" while compiling folks). However, that idea is silly.

      The principle of Other Buggers Efforts may be important in a University staffroom, but on the net with references to where everything comes from it makes no sense. If you package a distro you get to call it just about anything you like, if you are on the sidelines yelling at others you really don't get a lot of say in things in most cases.

  7. Minix on a modern machine? by Achra · · Score: 3, Interesting

    Um, how relevant is Minix these days? Is it honestly intended to be used on a PC or is it aimed squarely at embedded devices? I'll admit, I really enjoyed Minix back in the old days, on a single 360k on an 8088.. It was quite an amazing trick. But NOW?

    --
    Each processor would proceed sequentially as if it had been better for them not to rise against Saul.
    1. Re:Minix on a modern machine? by Inominate · · Score: 4, Informative

      It's not relevant as an actual operating system. It's relevance lies in it's use in teaching operating system design. Minix is a very simple, yet complete OS.

    2. Re:Minix on a modern machine? by E1ven · · Score: 4, Informative

      Historically, that's been true, but the 3.0 version seems to be re-targetted toward being a more functional OS as well.
      While I'm sure it's still primarily intended for Teaching, He's focusing on reliability as the selling point of the new version-
      It's got an advantage over Linux in that all drivers run in user-space. That means drivers can't bring down the whole kernel. Given that most kernel bugs come from driver implementations, this is a very nice feature.

      "MINIX 1 and 2 were intended as teaching tools; MINIX 3 adds the new goal of being usable as a serious system on resource-limited and embedded computers and for applications requiring high reliability."

      --
      Colin Davis
    3. Re:Minix on a modern machine? by worf_mo · · Score: 0, Redundant

      What you say is true for Minix 1 and 2, but Minix 3 seems to head for a different route (from TFA): MINIX 1 and 2 were intended as teaching tools; MINIX 3 adds the new goal of being usable as a serious system on resource-limited and embedded computers and for applications requiring high reliability.

    4. Re:Minix on a modern machine? by Anonymous Coward · · Score: 0

      It's got an advantage over Linux in that all drivers run in user-space. That means drivers can't bring down the whole kernel. Given that most kernel bugs come from driver implementations, this is a very nice feature.

      Today I found a mallock-deadlock that allocated all memory in my machine and froze it dead in 20sec. This program has run for years on irix where the OS has taken care of this error. On linux there are so many userspace errors that come from a
      blury userspace/kernel interface when using low level c system calls.

    5. Re:Minix on a modern machine? by Trejkaz · · Score: 1

      Indeed. Particularly with this trend of certain graphics card manufacturers releasing binary-only drivers which the community can't fix when bugs are found, it would be good to have some means of fallback for when a shoddily hacked up driver crashes.

      --
      Karma: It's all a bunch of tree-huggin' hippy crap!
  8. This guy told linus by rolfwind · · Score: 0

    that he'd give him an F in Operating System design in the mid-90s right when linux was getting started.

    Given that I never heard of minix being used outside the academic world (and even then, not much) I have to wonder if this guy is some type of Ivory Tower type or if this OS has any intriqueing feature over anything else out there. The only other mention of minix I've seen was the Filesystem to format floppies with...

    1. Re:This guy told linus by Anonymous Coward · · Score: 1, Insightful

      That's because Minix is an academic operating system, meant to be used for teaching and perhaps research purposes. It's not supposed to be taking over the world of operating systems. That was part of the motivation for Linus and friends to go off and make Linux because Tannenbaum didn't want Minix to be made overly complex and riddled with real-world inconsistencies and hacks (thus it could remain an effective teaching tool).

    2. Re:This guy told linus by LizardKing · · Score: 5, Insightful

      Linus would have deserved that "F" in operating system design, but he wasn't writing his kernel to get grades on a computer course. If he had been then he probably wouldn't have written a crude, monolithic kernel that was totally unportable. Apart from the crudity of it, those were his explicit goals - to write a monolithic kernel that would run optimally on his 80386. (Bear in mind that the Linux kernel we know today is pretty far removed from that early version in design and implementation).

      As for AT, he's a very smart guy. He writes books on operating system deign and networking that clearly describe quite complex topics. Even if you don't like the idea of microkernels, the "Operating Systems ..." book that describes the Minix kernel is an excellent read.

    3. Re:This guy told linus by asciiRider · · Score: 2, Insightful

      "This Guy"

      Is a TEACHER
      Is an AUTHOR
      Ia a HACKER

      Now shut the $^#( up before I hunt you down and stuff that minix formatted floppy up your A$$.

    4. Re:This guy told linus by Anonymous Coward · · Score: 0

      Err, no Linus would not have deserved an "F".

      This is an operating system that runs on more CPU architectures than any other in the world, and more diverse ones, including embedded systems without memory management units and under a meg of RAM, all the way up to SGI supercomputers that next year will be up to probably 2048 CPUs and 16TB of RAM.

      Linux throughout its history has almost always been the most performant in comparison with its contemporaries in terms of primitive operations like fork(), syscalls, context switches and the like.

      It was good enough for the likes of IBM, Intel, SGI, HP, NSA, NEC, Sony, etc to justify putting significant resources into, and most of those organisations continue to do so.

      No, Linus gets an "A" in operating systems design. He is the chief designer and architect of this system.

    5. Re:This guy told linus by Anonymous Coward · · Score: 0

      Why do you have so much repressed anger/violence?

    6. Re:This guy told linus by Azreal · · Score: 0

      Actually, gp is right. Linus would have deserved an F for his original design. Rewind to 1991. Linux was introduced to minix around 1987 and this inspired him to create linux. Around the end of 1991 linux 0.01 came out on newsgroups and was, imo, one huge kludge that would require some very serious work which linus realized and asked for help with. Within that same year, and with the help of various programmers, Linux 0.10 came out and was vastly improved but still seriously unstable. Anyways, the linux you see today or even as far back as 1993 had went through many itterations of change and refinement, and so for his original design, yes it probably would have deserved an F.

      --
      $sys$droids
    7. Re:This guy told linus by Anonymous Coward · · Score: 0

      Yes, and Linus is chief architect.

      Code may have been contribued from many many people, but Linus provided (to a *very* large degree up to 2.2) guidance, design, and has the final say of what goes and what doesn't.

      Look, Linux attracted most of the big IT companies, some of the brightest minds in the OS field, is responsible for billions of dollars annually, and blah blah blah.

      Meanwhile, Andy stewed in his ivory tower for 10 years and at some point not so long ago inflicted another irrelevant bit of code onto the internet.

      I'm fairly sure I know who gets the "A" and who gets the "F".

    8. Re:This guy told linus by MikeFM · · Score: 1

      Anyone that dares to write an OS in the age of Microsoft gets at least a C in my book if the damn thing can so much as boot and say Hello World. C'mon, give the guy some points for effort. How many students of OS design that got A's in the class have even bothered to write their own OS outside of school or work let alone post it for public review?

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    9. Re:This guy told linus by Anonymous Coward · · Score: 0

      Because you're still alive.

    10. Re:This guy told linus by Ulrich+Hobelmann · · Score: 1

      And with some right.

      Even today Linux suffers from lack of drivers. Sure, it's possible to write them, but they seem quite intertwined with the kernel and are infected by the kernel's GPL license, even though the driver's purpose is simply to add another hardware interface, not to hijack the kernel's functionality!

      A clean, minimalist kernel interface has its advantages, and I'll be looking into Minix. Maybe Minix isn't too useful as it is, but at least it's got clean fundament/architecture on top of which to build the rest.

    11. Re:This guy told linus by justins · · Score: 1
      Bear in mind that the Linux kernel we know today is pretty far removed from that early version in design and implementation

      Come on, you can say it. The early Linuxes sucked.

      There, that wasn't so hard. :)
      --
      Now before I get modded down, I be to remind whoever might read this that what I am saying is FACT. - bogaboga
    12. Re:This guy told linus by Anonymous Coward · · Score: 0

      Hey, I heartily congratulate the courage of anyone brave enough to publicly walk around with the handle "ASSRIDER". Keep chasing that rainbow!

    13. Re:This guy told linus by LizardKing · · Score: 1

      This is an operating system that runs on more CPU architectures than any other in the world

      I didn't realise we were talking about NetBSD ;-) Linux has gradually become more portable, but still has large chunks of machine dependent code that would have been better implemented had Linus set out to write a portable kernel. Linux allegededly runs on a number of platforms where it was only ever able to boot diskless or single user at best, and where the support has disappeared thanks to no centralised build or test environment.

      Linux throughout its history has almost always been the most performant in comparison with its contemporaries in terms of primitive operations like fork(), syscalls, context switches and the like.

      Bullshit. FreeBSD wiped the floor with Linux on i386 until a few years ago. Solaris still wipes the floor with Linux on anything more sophisticated than Joe Internet Startup Inc and their Dell servers. Try benchmarking Linux and Solaris on an SMP Opteron sometime and you'll find out what I mean.

      It was good enough for the likes of IBM, Intel, SGI, HP, NSA, NEC, Sony, etc to justify putting significant resources into, and most of those organisations continue to do so.

      All that happened was that PC technology became just about good enough to perform serious server tasks, and the likes of IBM et. al. saw that pushing Linux was a cheaper option than porting their existing enterprise operating systems.

      No, Linus gets an "A" in operating systems design. He is the chief designer and architect of this system.

      Nope, Linus hasn't been heavily involved in the design of many of the subsystems that make up the kernel. VM? Rik van Riel and Andrea Achanegeli. Schedulers? Con Kolivo (sp?). VFS? Al Viro. And that's just a few examples.

  9. for those that don't know by Anonymous Coward · · Score: 5, Funny

    In case you don't know, Andy was the professor who originally suggested to Linus that he create a kernel, and then provided all the support and positive encouragement that would obviously be needed to successfully complete such an undertaking. He knew from the outset that Linux was going to be a massive hit. He is truely one of Computer Science's great visionaries.

    1. Re:for those that don't know by diegocgteleline.es · · Score: 0

      and then provided all the support and positive encouragement that would obviously be needed to successfully complete such an undertaking. He knew from the outset that Linux was going to be a massive hit

      No, he didn't. He told linus he'd have gave him a F in OS design, told him that "microkernels have won" and believed that all the future operative systems would be microkernels. I can't see how he "knew that linux was going to be a massive hit" and how he "encouraged" linus...

    2. Re:for those that don't know by Anonymous Coward · · Score: 3, Funny

      Whoosh!

    3. Re:for those that don't know by Anonymous Coward · · Score: 2, Insightful

      That stiff breeze you just felt was from the sarcasm of the OP going over your head at mach 1...

    4. Re:for those that don't know by nova20 · · Score: 0

      That's not the way I heard it.

      I understood that Linus took it upon himself to code the kernel that is now known as Linux -- something that was like minix, but a little "friendlier" (for lack of a better word). Andy Tenenbaum didn't like it (and said that the project wouldn't catch on) because Linus had kinda showed him up, but Linus, in his ever-subborn way, basically told him to stick it where the sun don't shine.

    5. Re:for those that don't know by roman_mir · · Score: 1

      I would like to ask you something: what is it in a human's head that disables the ability to distinguish humour from serious statements? when did you first find out that you are one of those unlucky affected by this condition?

      Thanks.

    6. Re:for those that don't know by slavemowgli · · Score: 1

      Oh, come on. The grand-parent was *so* obviously being ironic - don't tell us you didn't realise that.

      --
      quidquid latine dictum sit altum videtur.
    7. Re:for those that don't know by Anonymous Coward · · Score: 2, Funny

      Thankyou for such an enlightening and fact-laden post. I think I'll add it to Wikipedia.

    8. Re:for those that don't know by Anonymous Coward · · Score: 0

      I think Uncyclopedia would fit better.

    9. Re:for those that don't know by RLiegh · · Score: 1

      I have no idea which is funnier; the OP or the reactions of the humour impaired who responded to it as if it was serious!

  10. What I'm really after by Anonymous Coward · · Score: 0

    Is a free look-alike version for AT-386 computers. Does such a thing exist?

  11. Is there a VMWare disk image? by nmoog · · Score: 3, Interesting

    That'd be cool to give this a bash with our shiny new VMWare players!

    1. Re:Is there a VMWare disk image? by nmoog · · Score: 3, Funny

      Mental note... RTFA then post... VMWare Disk Image located on their homepage!

      Slashdotted but. Any mirrors?

    2. Re:Is there a VMWare disk image? by MikeFM · · Score: 1

      I'm still looking for a FreeDOS image myself. Damn! I wanted to play Commander Keen in my glorious emulator!

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    3. Re:Is there a VMWare disk image? by BushCheney08 · · Score: 1

      VMWare Player tools for fun (and profit???)

      Blank VMWare disk image
      FreeDOS boot/install CD and/or FreeDOS boot floppy image
      Daemon Tools (virtual CD drive) and/or Virtual Floppy Drive

      --
      Be a real patriot: Question authority. Think for yourself. Formulate your own conclusions.
    4. Re:Is there a VMWare disk image? by ares284 · · Score: 1

      How about this?

      http://doxbox.sf.net/

      -Ares

  12. But... by orzetto · · Score: 2, Funny

    ... does it run on Linux?
    (points the right pinky finger to the lip and laughs hysterically)

    --
    Victims of 9/11: <3000. Traffic in the US: >30,000/y
    1. Re:But... by biryokumaru · · Score: 2, Informative

      Why, yes, yes it does.

      --
      When you're afraid to download music illegally in your own home, then the terrorists have won!
  13. Im sure nothing will egg him more by MajorDick · · Score: 1, Funny

    Than being posted under the LINUX section of Slashdot either.

    Just think ot the Irony, of the Fater , so to say being listed as a Child.

    While not a direct descendent Minix was CERTAINLY the original inspiration for Linus ("Ill tak that as gopsel since Linus himself said so:).

    But now what nearly 15-18 years later and well we see no Minix section of Slashdot....

    1. Re:Im sure nothing will egg him more by LordSnooty · · Score: 1

      But now what nearly 15-18 years later and well we see no Minix section of Slashdot....

      That'll be 'cos no bugger's using it.

  14. Deja vu by ladybugfi · · Score: 1, Informative

    Ahh, I used to run Minix 1.X on an Atari ST ages ago, maybe it's time to take a nostalgia trip.

    However, while I agree that microkernels are conceptually smarter, Linux has clearly won the "unix on a PC hardware" contest. But then again, as far as I could tell, that contest was never on AST's agenda anyway. For him the Minix system was a teaching tool.

    1. Re:Deja vu by justins · · Score: 1
      But then again, as far as I could tell, that contest was never on AST's agenda anyway.

      I'm pretty sure he has a blurb on his web page where he thanks Linus for making Linux, as people stopped asking him for stuff which didn't fit in Minix.
      --
      Now before I get modded down, I be to remind whoever might read this that what I am saying is FACT. - bogaboga
  15. Mirrors, Mirrors on the wall by DreddUK · · Score: 1

    OK, any mirrors to the VM image here pretty please?

    --
    "If A equals success, then the formua is A=X+Y+Z. X is work. Y is play. Z is keep your mouth shut" - A Einstein.
    1. Re:Mirrors, Mirrors on the wall by berryvanhalderen · · Score: 2, Informative

      Please don't, as this is also a nice gathering tool for measuring the slashdot effect and see if our replicated web server is holding out. We are using a dozen machines over the world to host the content.

    2. Re:Mirrors, Mirrors on the wall by MikeFM · · Score: 1

      Your network is slow. Load balancing would be more impressive if your pipes were faster. What's your criteria for throwing my own server into your mix? My hosting provider has the best speeds I've ever seen and I'm used to having multiple OC-12 circuits to play with.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    3. Re:Mirrors, Mirrors on the wall by Anonymous Coward · · Score: 0

      Well, your replicated web server is hosed.
      Mirrors? I'd like to have the VMWare image.

  16. A possible performance benchmark... by whynotme · · Score: 1
    In fact, most of the time when a driver crashes it is automatically replaced without requiring any user intervention, without requiring rebooting, and without affecting running programs.
    So, is this the only modern OS whose performance can truly be measured in device-driver-megaflops/sec?
    1. Re:A possible performance benchmark... by Shano · · Score: 1

      If your device driver is flopping over a million times a second, you might want to look into a debugger, regardless of microkernel / monolithic wars.

  17. The code is nice by DavidNWelton · · Score: 4, Interesting

    A couple of years ago, I was doing some hacking with the eCos embedded operating system and decided that I wanted to load data off the floppy before running the application, and so needed a floppy driver. Of course, I looked at Linux and BSD systems first, but they had big, hairy drivers. To be fair this is true partially because they try and support all kinds of weird hardware, but they also contain calls into lots of other parts of the system. On a whim, I got out my minix book, looked at the source code, and found the port was a lot easier, and finished it up in a few days (at least reading, I didn't need to write). In any case, the results are here:

    "Scivoli": http://www.dedasys.com/freesoftware/ecos.html

    and an article (in Italian): http://www.dedasys.com/articles/ecos.html

  18. Just for fun by slashflood · · Score: 1

    Wow, I was just reading "Just For Fun" for the second time, mainly because of the lack of other books and today I was wondering what happened to Minix. In his book, Linus describes what is wrong with Minix and microkernels in general.

    The Tanenbaum-Torvalds Debate

  19. remembering the old tanenbaum vs linus debates.. by hkultala · · Score: 2, Interesting

    .. so does it finally have a multithreaded filesystem?

  20. So the Minix server's down? by Anonymous Coward · · Score: 0

    That's a good advert.

  21. Comes full circle: minix copied - linux - minix by Anonymous Coward · · Score: 0

    Comes full circle: minix copied -> linux -> minix 3. I see and feel the humour.

  22. Oops... might have gone a little overboard by dascandy · · Score: 1

    My hobby OS (am moderator at www.mega-tokyo.com - OS development board) has around 8000 lines of code for just the core of the kernel... Must admit, I probably do have better support for threads and more layers and hierarchical constructs to make the code maintainable. It takes him years to bring out a new version, it takes me only a few months.

    1. Re:Oops... might have gone a little overboard by MichaelSmith · · Score: 1, Funny
      Must admit, I probably do have better support for threads and more layers and hierarchical constructs to make the code maintainable

      On the other hand, perhaps you have used more comments.

    2. Re:Oops... might have gone a little overboard by j-pimp · · Score: 1

      It takes him years to bring out a new version, it takes me only a few months.

      Did you ever think that maybe he's not devoting as much time to you to improving his OS. Also, he purposely keeps the OS at a level where it can be studied in one semester.

      --
      --- Justin Dearing http://www.justaprogrammer.net/ We're just programmers.
    3. Re:Oops... might have gone a little overboard by dascandy · · Score: 1

      No, rest assured, it's definately not the comments...

  23. More reliable by samjam · · Score: 2, Interesting

    "yes, he still thinks that micro-kernels are more reliable than monolithic kernels ;"

    Does anybody dispute this?

    AFAIK reliability is not the main pressing benefit of a monolithic kernel design so much as being able to scramble all over the internal structs of other kernel modules without needing a context switch, which can be very helpful and quick.

    Sam

    1. Re:More reliable by Anonymous Coward · · Score: 0

      The shared memory issue. It's possible to share memory in protected read only segments so, for read access anyway, you get the efficiency of shared memory with the robustness of a micro kernel. There's some esoteric lock-free techniques needed to ensure the read only data appears in a consistent state, but definitely doable now. See current "Process level smart pointers" in comp.programming.threads.

  24. Old laptops by Kim0 · · Score: 2, Interesting

    I have a number of old laptops lying around. It would be nice to use them for embedded systems. Linux is too big to fit. I guess Minix has too few drivers. What to do? Any recommendations?

    Kim0

    1. Re:Old laptops by Vo0k · · Score: 4, Informative

      NetBSD.
      I've found myself in similar situation once, Linux or Solaris wouldn't fit with reasonable amount of useful stuff on a 200M harddrive of an old SUN. Then I managed to fit most of the NetBSD distro, with 2 desktop managers, Netscape Navigator (pre-Moz times), bunch of servers for running a remote diskless workstation and still managed to cut 40M of diskspace for swap memory for that remote workstation :)

      --
      Anagram("United States of America") == "Dine out, taste a Mac, fries"
    2. Re:Old laptops by MichaelSmith · · Score: 1
      What to do? Any recommendations?

      NetBSD

    3. Re:Old laptops by Tx · · Score: 2, Interesting

      Windows 98 can be shrunk to ~4MB, and has plenty of drivers. And I kid thee not, I have seen Windows 95 used as an embedded OS in some very expensive products. Scary.

      --
      Oh no... it's the future.
    4. Re:Old laptops by Carrot007 · · Score: 1

      Hey I've even seen them leave sol.exe on those expensive embedded machinery, much fun!

      --
      +----------------- | What is the question!
    5. Re:Old laptops by megabeck42 · · Score: 1

      Should I feel that my linksys router can do more MIPS and has more RAM than your Sun 3/60? :)

      --
      fnord.
    6. Re:Old laptops by megabeck42 · · Score: 1

      Err, I mean, should I feel bad about it. Apologies. I suffered through using Sun3's for a while too.

      --
      fnord.
    7. Re:Old laptops by SharpFang · · Score: 1

      No.
      The tries to install bigger systems were painful. But once I decided for NetBSD, it was going smoothly. Sure there was lots and lots of work to do, and huge amounts of documentation to read to have things done. You need some 5 or 6 different servers configured to have the dickless running, almost all were new to me, recompiling the kernel is totally different than in Linux, new package system, new /dev entries, doing some really weird stuff with NFS, and since the box lacked a floppy or CDROM, I had to set up bootstraping it from the net on yet another SUN, running Solaris. But it all was going surprisingly smoothly. It was some 3 days of work, but it was plain getting things done, not stumbling blindly around and clicking buttons in hope it would start and troubleshooting new problems. Simply, bilding it, from blank harddrive to complete system with all the extras, taking a hour or two to learn the new step, another hour or two to install and configure the piece, half a hour to add given content (/etc copy, boot image etc), then moving to the next step. Real pleasure. And having the ancient machine to run faster than some way more modern machines around was really rewarding!
      NetBSD is very "rough", but also clean in this roughness. No fancy GUIs (even like ncurses), almost all in plaitext docs and config files. Very few "autoconfig" scripts, most stuff has to be configured by hand, but the system is small enough that it's not overwhelming. You never get lost because the number of components is well within your capacblity of remembering. The docs are very clear and accurate, and you don't have to browse pages and pages of useless junk to reach a single line you want, instead you just get 2-3 screenfuls of the file and need to read it whole from the beginning to end, because it contains everything you need to know in the subject and not a word more.

      Linux is growing at scary pace. 5 years ago there were maybe 10% files in /etc I didn't know the meaning of. Today, I understand less than 30% of the /etc files. NetBSD is pleasantly "primitive" comparing to that.

      --
      45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
    8. Re:Old laptops by johansalk · · Score: 1

      Hello, I'm a linux user (beginner) who decided that my taste is in debian and slackware, as I do really appreciate a simple, stable and fast OS and do want to learn - in particular, I felt by learning slackware I could use almost any linux, but wasn't sure the same was true for suse/redhad, and I did not like Linux distros that try too hard to be like windows. Lately I've been wondering about the BSDs and in particular NetBSD. Would you suggest I invest some time in learning them or just stay with linux?

    9. Re:Old laptops by Vo0k · · Score: 1

      Depends on what you want. Linux is mainstream and will remain mainstream. NetBSD is a narrow side road that can help you learning a lot of philosophy of the system, is a rather pleasant experience, but doesn't lead too far. So if you feel like investing some of your time in learning a new skill that comes in handy if you are facing obscure marginal architectures and obsolete-but-good hardware, NetBSD is definitely worth a try. But as all marginal stuff, there's a good chance you will never face it, and installing NetBSD on anything with better than 500MHz CPU is some kind of mistake. It's good for some computer necromancy and surely teaches a thing or two about the workings of the net and Unices in general, but by itself it's too -small- to be of significant value by itself. Although it obviously makes some nice simple servers or comfortable "thin clients".

      --
      Anagram("United States of America") == "Dine out, taste a Mac, fries"
  25. X11 port? by CyricZ · · Score: 2, Interesting

    On the news page it states that 'The port of X Windows is coming along well.'

    Which implementation of X is it that is being ported? I would hope that it is X.org, and at least the 6.8.2 release.

    --
    Cyric Zndovzny at your service.
  26. MINIX3 goals by Anonymous Coward · · Score: 0

    It is funny, it says a main goal of MINIX 3 is to run in resource constrained environments.

    Andy then goes on to boast that it runs in 8MB RAM "with some tweaking". Meanwhile you've got Linux running in 2MB RAM out of the box, with a full TCP/IP stack and probably 1/2MB RAM when cut down and on MMUless systems and with some tweaking.

    Linus should post a message to their mailing list and tell Andy he'd give MINIX3 an "F" for resource constrained environments.

    1. Re:MINIX3 goals by CyricZ · · Score: 1

      The Linux systems that run in 2 MB of RAM are hardly "Linux" systems. Some code is borrowed, but the experience is totally different. They're not suitable for any serious workstation tasks, like Tanenbaum is aiming for here.

      --
      Cyric Zndovzny at your service.
    2. Re:MINIX3 goals by Anonymous Coward · · Score: 0

      Err, WTF? No, wrong, they are Linux systems.

      They use the Linux kernel. What do you mean "borrowed code"? That didn't make
      sense at all dude, they just run the plain old Linux kernel.

      And considering MINIX3 doesn't even have an X-Windows port yet, I doubt he'll get a
      "serious workstation task" running in 8MB either.

    3. Re:MINIX3 goals by Slashcrap · · Score: 1

      They're not suitable for any serious workstation tasks, like Tanenbaum is aiming for here.

      Can you please point out at least one place where Tanenbaum states that he is aiming for serious workstation use?

      Since everyone else knows that it's for teaching use, you're going to need to provide some evidence in order to prove that you're not batshit crazy.

  27. live CD / vmware by boojit · · Score: 1

    The live CD seems to work fine with VMWare workstation. Just make sure you use an IDE hard drive instead of a SCSI, and point your CD-ROM device to the ISO image.

    DaC

  28. RTFA by fandrieu · · Score: 1, Redundant

    It's relevance lies in it's use in teaching operating system design

    used to be true, but not any more, from TFA:

    "MINIX 1 and 2 were intended as teaching tools; MINIX 3 adds the new goal of being usable as a serious system on resource-limited and embedded computers and for applications requiring high reliability."

  29. Tanenbaum gets a failing grade by idlake · · Score: 4, Insightful

    Tanenbaum rightly criticized Linus for creating a big monolithic operating system kernel, but at least Linus was copying something that was successful and he made it a success himself.

    But, geez, how often do microkernels have to fail before Tanenbaum will admit that there must be something fundamentally wrong with his approach, too? Microkernels attempt to address the right problem (kernel fault isolation), just in such an idiotic way that they keep failing in the real world. But instead of a detailed criticial analysis of previous failures, Tanenbaum and Herder just go on merrily implementing Minix3, apparently on the assumption that all previous failures of microkernels were just due to programmer incompetence, an incompetence that they themselves naturally don't suffer from.

    Both Linux-style monolithic kernels and Tanenbaum-style microkernels are dead ends. But at least Linux gets the job done more or less in the short term. In the long term, we'll probably have to wait for dinosaurs like Tanenbaum to die out before a new generation of computer science students can approach the problem of operating system design with a fresh perspective.

    1. Re:Tanenbaum gets a failing grade by thallgren · · Score: 1

      What are your comments to very performant implementations like L4 and Qnx?

    2. Re:Tanenbaum gets a failing grade by eugene259 · · Score: 1

      It is a question of viewpoint, isn't it? If widespread use and success was important to Tanenbaum I guess he would have stopped long time ago as minix never took off. However it seems he is more of a researcher than a pragmatist like Linus seems to be and keeps minix going as a personal research/pet project. As for amount of failed microkernel architectures indicating it is 'wrong', well, VHS won over Betamax, over the years old x86 won over countless 'better' architectures, MS-DOS won over a lot more pleasant (D)OSes, etc, etc, etc... Just because something is popular doesn't mean it is there because it is the best. Maybe both of the designs are dead ends but thats just a speculation for now and the monolithic kernel design should be the dinosaur in your example as it came before the microkernels and out of the two microkernels *are* the fresher design which in its day was trying to break the mould and revolutionize the os architecture.

    3. Re:Tanenbaum gets a failing grade by idlake · · Score: 2, Informative

      At issue isn't whether Tanenbaum is right or whether he is wrong, at issue is his methdology. Tanenbaum is unscientific: he focuses on a single variable and ignores all the others; he fails to even state his claims properly, let alone support them with data; and he fails to justify a novel approach with a detailed empirical analysis of prior work. Tanenbaum just tinkers and makes grand claims. That's why he should receive a failing grade.

      As for microkernels being new, they are not. They have been around for at least a quarter of a century (arguably longer), and they have received more than their fair share of attention and study. There have been many other ideas in OS design since then; if anything deserves attention, it is them.

      Perhaps the most obvious and straightforward idea for how to improve reliability and decrease development costs for operating systems is to start applying modern, proven software development technologies: object-oriented programming languages, tools, design methodologies, safe runtimes, reflection, garbage collection, etc. The hypothesis that doing so improves reliability is far more plausible than Tanenbaum's hypothesis that we can stick with using ANSI C if we only use some hare-brained scheme of dividing everything up into separate address spaces. And, in fact, there is actual experimental evidence that using safe runtimes with monolithic kernels is more efficient for fault isolation than using unsafe runtimes with microkernels.

    4. Re:Tanenbaum gets a failing grade by 0xABADC0DA · · Score: 5, Interesting

      It's because traditional microkernels solve the wrong problem. The goal is reliability and flexibility (user-space drivers and whatnot). The wrong problem is using separate memory spaces to achieve the goals. They are just too clumsy... they are ridiculously slow, are coarse grained (4k page is the smallest unit), and you cannot apply a filter to memory accesses.

      If the microkernel was combined with a safe language, like Java or C#, then the problems would go away. You wouldn't need to change the page table, so that massive penalty is not there. Accessing memory through a memory object would allow any arbitrary range (down to single bits). You could also apply a filter, so the driver could implement the commands to the disk but the hardware access object would only allow valid use of the bus; this wouldn't be perfect but would greatly increase reliability over microkernels, which are already much more reliable than monolithic.

      And speed? It could be faster than C-based code for various reasons (using the dirty bit to accellerate garbage collection, no context switches, etc). It's not like there isn't precendent: the berkely packet filter is actually an interpreted bytecode that is run inside the kernel. It has a number of restrictions to ensure safety (like only branching forwards), but basically in all unix operating systems it is a giant switch statement that interprets the bytecode. This is plenty fast enough to handle the packets, orders of magnitude faster than sending the packets into user-space.

      If Tanenbaum really cared about reliability or safety or simplicity he would make a managed microkernel, not more of this C/asm based crap.

    5. Re:Tanenbaum gets a failing grade by Salamander · · Score: 2, Interesting
      Tanenbaum is unscientific: he focuses on a single variable and ignores all the others; he fails to even state his claims properly, let alone support them with data; and he fails to justify a novel approach with a detailed empirical analysis of prior work.

      Bullshit. He has written whole books on the subject, stating his claims and supporting them with data more than you will ever do in your entire lifetime.

      As for microkernels being new, they are not. They have been around for at least a quarter of a century

      Yes, that's about how long ago Tanenbaum suggested them. Criticizing Tanenbaum's idea as "not new" when he's the very one who makes it quite old is just ridiculous.

      Perhaps the most obvious and straightforward idea for how to improve reliability and decrease development costs for operating systems is to start applying modern, proven software development technologies: object-oriented programming languages, tools, design methodologies, safe runtimes, reflection, garbage collection, etc.

      Object-oriented programming, tools, etc.? Very useful in an OS context, where dispatch tables for things like device drivers and filesystems predate the languages you probably use. Design methodologies? Obviously useful, and tautologically so, but what an OS designer considers a good methodology might not be the same as what some UML/pattern masturbator thinks is good. Safe runtimes? Yeah, that would suck for performance even more than microkernels are claimed to (incorrectly in light of examples such as L4 and QNX). Reflection? Simply useless in this context. Garbage collection? Ridiculous.

      Have you ever worked on operating systems? It sure doesn't look like it. What you propose might be good for application space, but part of the reason those tools and applications work is because of the support they get from the kernel and other parts of the base system on which they run. Kernels and embedded systems are fundamentally different. Some of what you suggest might provide valid alternatives to the problem of what to do after code has failed, but none of it addresses the issue of how to prevent it from failing in the first place. Part of the point of microkernels is to reduce dependencies and make code more maintainable; it's a specific application of good old modularity, just as OOP is a different application of that same age-old concept. All of the things you mention are essentially orthogonal to microkernel vs. monolithic. You could implement every one of your ideas in either context, but I guarantee that a microkernel without reflection and garbage collection would be more maintainable and thus (over time) more robust and performant than a monolithic kernel with them. Stick to wimpy user code. Leave OS design to those with experience in that domain.

      --
      Slashdot - News for Herds. Stuff that Splatters.
    6. Re:Tanenbaum gets a failing grade by 0xABADC0DA · · Score: 2, Insightful

      What you propose might be good for application space, but part of the reason those tools and applications work is because of the support they get from the kernel and other parts of the base system on which they run.

      The vast majority of what a monolithic kernel does *is* application-like. Keeping track of lists and hashtables of sockets, files, processes. Accessing them in O(1) time. Allocating and deallocating memory for those. Keeping track of buffers and balancing cache sizes. These are all the things that object-oriented, managed languages are good at and where C/asm sucks big time.

      C is suited for the few parts of the kernel that require running in fixed time windows or direct hardware access. But those places are very few. The fact that the rest of it is in C is because a) that's how it's always been done, b) people are short-sighted and lazy so don't mix safe/unsafe code because it takes more up-front work c) the people writing the kernel code couldn't understand for example the hotspot optimizer if they tried. Hell these people optimize the freakin caches lines to save a few nanoseconds but don't give a crap that you have to run at least 1000 user-space instruction per system call or half the processor time is completely wasted.

      You safe-kernel naysaysers act like writing kernel code is hard. It isn't. It just takes a lot of patience and diligence (mostly because it's in C). It's not like there's anything CS-hard in the linux kernel.

    7. Re:Tanenbaum gets a failing grade by idlake · · Score: 1

      Yes, that's about how long ago Tanenbaum suggested them. Criticizing Tanenbaum's idea as "not new" when he's the very one who makes it quite old is just ridiculous.

      I'm not criticizing them for being an old idea, I'm just pointing out that the idea has had a long time to prove itself.

      You could implement every one of your ideas in either context, but I guarantee that a microkernel without reflection and garbage collection would be more maintainable and thus (over time) more robust and performant than a monolithic kernel with them.

      Experience with Mach, Hurd, Darwin, and Minix shows that this is clearly not the case: many common microkernels have proven to be more difficult to extend and maintain, to be less robust, and to perform worse than monolithic kernels.

      Object-oriented programming, tools, etc.? Very useful in an OS context, where dispatch tables for things like device drivers and filesystems predate the languages you probably use.

      Yes, and in the 21st century, we have standardized these things and put them into programming languages and runtimes. People like Tanenbaum should move out of the 1960's and get with the program.

      All of the things you mention are essentially orthogonal to microkernel vs. monolithic.

      That is quite incorrect. Microkernels are an attempt to overcome the problems with unsafe, static runtimes and languages by putting components into separate address spaces. If you have a safe, dynamic runtime, you don't need a microkernel architecture.

      Kernels and embedded systems are fundamentally different.

      That assumption is your and Tanenbaum's mistake. Among software developers, people like you are among the last holdouts that think it's OK to write millions of lines of C code with ad-hoc self-invented object-like dispatch tables and manual storage management. And then you come up with schemes like microkernel architectures to try and work around those self-created problems.

      Stick to wimpy user code. Leave OS design to those with experience in that domain.

      Yes, and in a nutshell, that sums up the problem: OS designers have an attitude problem. Instead of making it easier for people to modify the kernel, they try to keep it some obscure art form. I think the reason they can get away with it is because kernels matter less and less. Application programmers stopped expecting anything useful from kernel developers long ago and started implementing security, remote file access, hardware access, and other features completely in user code. I suppose it's a form of "microkernel" as well.

    8. Re:Tanenbaum gets a failing grade by Salamander · · Score: 2, Insightful
      You safe-kernel naysaysers act like writing kernel code is hard. It isn't. It just takes a lot of patience and diligence (mostly because it's in C). It's not like there's anything CS-hard in the linux kernel.

      The classic response of someone who has never actually done any serious kernel work. Just because it's not CS-hard doesn't mean it's not real-world-hard, and I think I know a bit about that because I've been solving problems that are hard in both senses for quite a while. Your use of "naysayer" only gives away your own bigotry. Think about what "safe" means in that context. It means that the code doesn't have direct access to underlying resources, with that access then done on your behalf by "someone else" but there is no someone else when you're the kernel. Those "safe" environments require exactly the kind of performance-robbing intermediation for which you criticize microkernels; in a way, what you're proposing is actually a microkernel of a different (and inferior) sort. Do you want to have every PCI-register access trap to a safety-guaranteeing handler? If you don't see how badly that would suck, grow a clue.

      Compile-time safety checks are a wonderful thing, and I've applied cutting-edge forms of that technology in both kernel and user work. The run-time checks of your "managed code" utopia, though, are simply impractical for an OS kernel.

      --
      Slashdot - News for Herds. Stuff that Splatters.
    9. Re:Tanenbaum gets a failing grade by 0xABADC0DA · · Score: 1

      The classic response of someone who has never actually done any serious kernel work.

      Maybe so, but if you are trying to imply I don't know what I'm talking about then that's bullshit. I've had no problems writing complicated code in FreeBSD and Linux kernels -- other than it being in C.

      There's plenty of "performance-robbing intermediation" in safe languages AND in C, because of the extraordinary lengths that have to be gone to for simple problems (unnecessarily copying buffers, no callbacks, maintaining complicated memory maps, having to maintain manual memory ownership). You say safe languages don't have direct access to the hardware, but that's misleading. For example, if your driver accesses memory through an object (ie, memory.write(location, abyte)) this would get compiled to just an "if (location >= min || location <= max) *(mem+location)=abyte" for example. Or you replace it with an object that does nothing and it gets completely removed, so there is no check and no overhead at all per write (and no safety).

      Also you say "there is no someone else in the kernel". Of course there is. You have 4k or so of assembly that gives access to the hardware-specific stuff (memory space registers, page table flush instruction, interrupts). How much of the "someone else" do you think something like Java uses anyway? The core is pretty much *all* written in java. Check our jxos.org's Java operating system. Run it in vmware and you get a simple network stack, *GUI*, processes, etc. It was written by like 2 guys instead of watching TV. This stuff is doable and plenty fast; that's why I describe you as a "naysayer".

    10. Re:Tanenbaum gets a failing grade by naasking · · Score: 3, Interesting

      Tanenbaum is unscientific: he focuses on a single variable and ignores all the others; he fails to even state his claims properly, let alone support them with data; and he fails to justify a novel approach with a detailed empirical analysis of prior work.

      Even if what you say is true, there are plenty of others making very detailed analyses of microkernel architectures, and they have reached many of the same conclusions: that microkernels are feasible, useful, and practical, if done correctly. The real problem is that microkernels have a stigma attached to them, and because they are hard to properly design and implement. As such, only researchers have traditionally worked on them, and we all know researchers are not going to develop a full-featured system like Linux. Hopefully, that will change with CapROS.

      See my other posts in this thread:
      Performance
      Examples of microkernel sytems

    11. Re:Tanenbaum gets a failing grade by soldack · · Score: 1

      I have worked on linux and windows device drivers and embedded code on systems like VxWorks and on proprietary embedded systems. I have also written user space programs (math libraries, configuration programs, etc). I find that writing kernel code is much less forgiving then user space code, especially when working with hardware. The mistakes that can be made can be very subtle and much more difficult to debug given the systems available today. Deadlock your user space program and it just stops. Deadlock your kernel and your whole system hangs. Ever have the joy of having hardware trash system memory due to undocumented limitations on usage? Have you ever watched in horror as a low memory reference (like null->member) leads to a random hardware access instead of being caught by the system? When you create a complete system with no memory protection because you don't have the hardware for it, it is more difficult. There is a reason that there are a small number of folks who work in the embedded and kernel spaces.

      I am not saying that user space programming is easy. Kernel space programming brings its own challenges that user space programmers almost never have to consider. Meanwhile it still has many of the same challenges that user space programming has.

      I do agree that many kernels do do lots of the same things that user space programs could do and perhaps some of that should be pushed to user space. The problem is that attempts to move things to user space or use protected languages (like java) for kernel have not worked well so far. They tend to require more resources or run slower which often kernels don't want and embedded systems can't afford. Perhaps your idea of a mix might work. But isn't that going in the microkernel direction with the microkernel being the " few parts of the kernel that require running in fixed time windows or direct hardware access" and the rest being a protected or managed language? By the way, "direct hardware access" is really not a small part of the kernel when you consider all the device drivers that require direct access to the hardware they are trying to support. I am curious how much of most running O/S kernels are devoted to O/S services and how much are handling specific hardware (NIC, storage card, video card, etc).

      --
      -- soldack
    12. Re:Tanenbaum gets a failing grade by Salamander · · Score: 4, Interesting

      Experience with Mach, Hurd, Darwin, and Minix shows that this is clearly not the case: many common microkernels have proven to be more difficult to extend and maintain, to be less robust, and to perform worse than monolithic kernels.

      How unscientific of you, to draw such an unrelated conclusion from that data. The operating systems you have mentioned have been less prevalent in the marketplace. They have had smaller numbers of users and, more importantly, engineers working on them than, say, Linux. That does not in any way demonstrate that they are more difficult to extend and maintain, as there are plenty of other reasons for what has happened in the market. How do you know that they wouldn't be even more marginal than they are had they been designed as monolithic kernels, or that Linux wouldn't be even more successful if it had been designed as a microkernel? What actual evidence do you have to say otherwise? None.

      Microkernels are an attempt to overcome the problems with unsafe, static runtimes and languages by putting components into separate address spaces

      Wrong. Shared vs. separate address space is an implementation choice; microkernel vs. monolithic is a design choice. That microkernels are typically implemented using separate address spaces is irrelevant. If you had actually worked in operating systems you'd also know that totally shared vs. totally separate are not the only options for address-space relationships. Linux's process/thread/address-space model is based (without attribution, naturally) on something called nUnix, which Dave Mitchell implemented and I inherited at Encore before Linux existed. One of its key ideas is/was that parts of a process could be shared without having to share everything. SysV's shared memory goes back even further than that. Even within the kernel one can implement some forms of inter-component memory protection without resorting to completely separate address spaces. Been there, done that. I was the one who wrote code at Encore to let two operating systems run side by side in the same box, on separate sets of processors with separate memory and exception vectors and - most importantly - so that a memory fault in one wouldn't take the other down. That was done in a slightly different context (one was an RTOS and the other a GPOS) but the same techniques could just as easily be applied to a microkernel.

      If you have a safe, dynamic runtime, you don't need a microkernel architecture.

      And how is that "safe, dynamic runtime" not itself a microkernel?

      Among software developers, people like you are among the last holdouts that think it's OK to write millions of lines of C code with ad-hoc self-invented object-like dispatch tables and manual storage management.

      Yeah, I'm such a dinosaur, working here in what is acknowledged as one of the leading-edge areas of the storage industry, implementing a highly available distributed system. Riiight. What do you do that anyone should remember you for, Mr. Expert? In actual fact I don't think it's a good idea to write "millions of lines of C..." when one has a choice. If I were to design another microkernel it would be every bit as current in terms of software-engineering methodology as anything you've ever done, but that doesn't mean it would be implemented as a "managed code" environment. I understand the concept of informed tradeoffs as opposed to mere uninformed dogma. I produce working and shipping systems based on that. Come back when you've done likewise.

      Instead of making it easier for people to modify the kernel, they try to keep it some obscure art form.

      OS development doesn't need to be made hard; it's inherently hard. In an OS, everything you do has to be done with an eye toward reentrancy and concurrency, performance and minimal resource consum

      --
      Slashdot - News for Herds. Stuff that Splatters.
    13. Re:Tanenbaum gets a failing grade by gr8_phk · · Score: 1

      You mean using seperate memory spaces is slower than writing all your apps in an interpreted language? I find that really really hard to believe. If it is true, then you would have to put the interpreter(s) in the kernel so no one could ever run a C program. If you could run arbitrary code, there would be major security issues with apps all running in the same memory space. I think we just need faster context switching.

    14. Re:Tanenbaum gets a failing grade by Godeke · · Score: 1

      You know, all that would be interesting if it wasn't blown out of the water by the existance of machines that used a high level language as the operating system. The Lisp machines seemed to do just fine running on hardware that directly supported Lisp itself as the assembly code, and I would argue that there is nothing that would prevent a modern incarnation of an OOP based version of the same ideas. You could use them in embedded design where memory footprints need to be kept small and processor speeds are poor, so inefficency hampers low cost design. Maybe call them Java Processors?

      --
      Sig under construction since 1998.
    15. Re:Tanenbaum gets a failing grade by 0xABADC0DA · · Score: 1

      A very reasonable response. Thank you.

      Yes there are weird hardware effects and for that matter difficulty in using any debugger that make kernel programming harder. I've done kernel programming before. I agree with that. But consider that for instance JavaOS runs the same with memory protection hardware and without it; it doesn't suddenly become significantly less stable or less capable. Drivers don't break.

      Perhaps your idea of a mix might work. But isn't that going in the microkernel direction with the microkernel being the " few parts of the kernel that require running in fixed time windows or direct hardware access" and the rest being a protected or managed language?

      Yes, exactly. JavaOS is built on a small (several k) microkernel that gives access to the hardware. Same with jxos and surely Microsoft's C# kernel research project. It's not the microkernel that's a bad idea, it's the C/asm implementation and using separate address spaces that necessarily follow from that.

      I am curious how much of most running O/S kernels are devoted to O/S services and how much are handling specific hardware (NIC, storage card, video card, etc).

      Well in latest linux kernel:

      1,133,377 lines: fs/ crypto/ ipc/ kernel/ lib/ mm/ net/ security/
      2,747,365 lines: drivers/

      Drivers usually take more code since they often have large tables in the code, and a running system only needs a small fraction of that (most will be modules that are never loaded). So I'd say it's a pretty safe bet that the vast majority of the code in a running kernel is not drivers.

    16. Re:Tanenbaum gets a failing grade by Olivier+Galibert · · Score: 1

      I doubt one can do anything intersting about kernel fault isolation anyway. If you look at linux conceptually, there isn't that much in there:
      - device drivers
      - memory management
      - filesystems
      - networking

      If a device driver crashes, unless it's usb you're essentially toast (think dma to lalaland, infinitely repeating interrupts...). And usb for funky devices tends to be done in userspace (see scanners with sane).

      If a filesystem crashes and it's a primary one you're toast since you can't access programs anymore. Secondary ones can be in userspace (see FUSE).

      If the memory management crashes, you're obviously dead.

      And if networking crashes, you at least lose all current connections, which can be quite annoying. Tends to be a very, very well tested part of the kernel in today's internet though.

      So, well, to the exception of networking which tends to be very stable anyway or dies fast, evrything that a microkernel could recover on crash tends to be doable and often done in userspace in linux. And probably in BSDs too, I just don't know them. So I'm not that sure there is a point to microkernels in practice, especially given their performance and engineering costs.

          OG.

    17. Re:Tanenbaum gets a failing grade by Salamander · · Score: 1
      You know, all that would be interesting if it wasn't blown out of the water by the existance of machines that used a high level language as the operating system.

      Implementing code in an HLL (a compile/link time decision) is not at all the same as running it in a "managed code" type of environment. Those LISP machines (LMI, Symbolics, or Xerox) compiled down to what the hardware understood, thereafter not requiring software mediation to do whatever it was they needed to do. As I'm sure you know, code runs faster directly on hardware than on top of an abstraction/emulation layer to translate between its interface and the hardware's. Yes, I know about JIT compilers but they don't fully solve that problem. Furthermore, those LISP machines ran on hardware specifically designed for that mode of operation. That's a far cry from today, when the most common processors on people's desktops or in their devices are not so narrowly targeted to running specific languages. Go ask a CPU designer about undoing the RISC Revolution and going back to "high level" processors like the iAPX432 or the various Burroughs stack machines. Those guys could always use a good laugh.

      Just because something can be done doesn't mean it should be done. Yes, we can implement monolithic kernels that run on special-purpose processors with all of the important primitives those kernels need implemented in hardware (which would be equivalent to implementing a microkernel in hardware). There might even be certain applications for which that would be a good idea - e.g. the same applications already using FORTH or "BASIC stamp" chips. For general-purpose computing with the expected complement of speed and bus-interface compatibility and virtual memory and multiuser protection, though, it would be an incredibly poor design choice.

      It's pretty amusing to hear such "back to the 70s" suggestions from those who have the gall to accuse others of being old-fashioned.

      --
      Slashdot - News for Herds. Stuff that Splatters.
    18. Re:Tanenbaum gets a failing grade by MemoryDragon · · Score: 1

      Actually L4, QNX, WindowsNT3.5 and other operating systems basically show that Microkernels both can be stable and very performant.

    19. Re:Tanenbaum gets a failing grade by Godeke · · Score: 2, Insightful

      I'm not suggesting "back to the future". I was simply pointing out you beat the poster up for suggesting things that have been done and continue to be done. Your personal opinion of the merits of the design notwithstanding, you for all practical purposes called the poster a moron for suggesting that OOP might have some use in operating system realms (the "third paragraph of beatdown"). Yet, it is quite clear that it isn't as far fetched as your verbal beating of the poster would make it appear.

      Not everyone is doing desktop programming and even there I'm not entirely convinced that hardware support for a more encapsulated view of the enviroment is a *bad* thing. Just because something is the current flavor (and has massive inertia due to installed bases) doesn't mean it is the only or even best way to do something.

      Of course, I take more offense at the fact that modern PC designs still rely on an hardware interrupt scheme that is so failure prone that a single misbehaving device can cripple the entire system. Which makes a lot of the discussion about "reliability through userland drivers" a fairly moot point.

      --
      Sig under construction since 1998.
    20. Re:Tanenbaum gets a failing grade by Salamander · · Score: 0, Flamebait
      It's not the microkernel that's a bad idea

      I hope you have a good rear-view mirror while you backpedal.

      it's the C/asm implementation and using separate address spaces that necessarily follow from that

      ...except that they don't. Microkernels have been implemented in other languages, and it has already pointed out to you that they have been implemented in single address spaces.

      Drivers usually take more code since they often have large tables in the code

      ...and you base that statement on...what? It's no more true of drivers than the rest of the kernel. You also fail to note that almost everything under fs/ and most of net/ is really driver code too.

      I'd say it's a pretty safe bet that the vast majority of the code in a running kernel is not drivers.

      By your own count, which is flawed, over 70% of the code is drivers. By a more realistic count it's likely to be 85-90%. Many would say that's the real metric of code size, since that's what has to be debugged and accounted for in designs. It's true that the percentage of code loaded into any given instance of the kernel is likely to be lower, but that actually highlights an interesting point: loadable modules represent an evolution toward microkernel ideas. In the Bad Old Days vendors shipped truly monolithic generic kernels, and then users would configure and relink for the devices they had. I don't recall offhand whether Linux was originally that way, but I think it was and I know for sure that BSD was. Even though they're loaded into a common address space, loadable drivers are very much a microkernel idea. Even process and I/O schedulers can be loaded nowadays, which moves us further in that direction (leaving little but the VM system). Now that they're widely adopted the majority of code that's loaded might not be drivers, but it's still not a vast majority and the majority of instructions during any given time quantum might well be drivers of one kind of another. By two out of three metrics - written, loaded, run - drivers are the majority of code. It's lovely that you could write a script to count lines, but it would be even better if you could understand the numbers you were looking at before you make more false claims.

      --
      Slashdot - News for Herds. Stuff that Splatters.
    21. Re:Tanenbaum gets a failing grade by idlake · · Score: 1

      The real problem is that microkernels have a stigma attached to them, and because they are hard to properly design and implement

      OK, we agree on that.

      Now, if that's the case, in what sense is a microkernel "more reliable"? Let's say that in 100 man years, my team can produce a fully functional and extensively tested monolithic kernel. If microkernels are harder to design and implement, in the same time, the same team may only implement some of the functionality and do less testing for an equivalent microkernel. So, the microkernel design is then actually inferior.

      And practical experience with kernels like Mach and Linux suggests that the microkernel design never catches up: no matter how long you hack on both kernels, the monolithic kernel always seems to be ahead.

      So, in what sense is the microkernel design supposed to be better than the monolithic design, then?

    22. Re:Tanenbaum gets a failing grade by naasking · · Score: 1

      Now, if that's the case, in what sense is a microkernel "more reliable"? Let's say that in 100 man years, my team can produce a fully functional and extensively tested monolithic kernel. If microkernels are harder to design and implement, in the same time, the same team may only implement some of the functionality and do less testing for an equivalent microkernel. So, the microkernel design is then actually inferior.

      You misunderstand. The base primitives are hard to get right, not the entire system built on top of those primitives. Once the base primitives are well defined and tested, development is very rapid and the system overall is quite reliable and flexible; moreso than monolithic systems. The past 30 years of microkernel research has been investigating what truly are the smallest set of primitives one can live with, and how to efficiently implement them in hardware (well, that's a naive view, but it serves our purpose here).

      OS researchers started with relatively monolothic microkernel designs (Mach), and then moved to progressively smaller and more principled designs as they discovered weaknesses in the other systems. We eventually ended up with L4, which has been argued as taking flexibility TOO far. The happy medium has mostly been struck in CapROS/EROS (and the next generation Coyotos will improve upon that even further). Whoever it was that predicted a few years ago that OS research was dead was only half right; it's not quite finished yet (see the Coyotos effort: a verified operating system implementation).

      The only thing that monolithic kernels gain you is that they were fairly straighforward to user-level programmers, since it's almost like programming in a restricted application environment. So your kernel developer base is potentially larger. This is another reason why monolithic kernels are more popular today.

      Microkernel kernels are harder to reason about because they are designed closer to the raw hardware, in the sense that the designers are counting raw cycles spent on a particular code path, and precisely how many cache misses are induced in a particular algorithm. You don't see this sort of anaylsis in monolithic kernels because it's nigh on impossible! There are simply too many variables to control.

      So I meant it was hard to design and implement the primitives, ie. the microkernel kernel itself, but the services and applications above it are far more resilient and flexible as a result.

      The microkernel is an ultra-small codebase that runs with dangerous priviledges; for example, Minix3 is only 4000 lines of code! With that 100 man years, you can probably test this microkernel code to hell and back again until you're extremely confident that there are little if any bugs in it (or you can verify it with automated proofs as the Coyotos effort is attempting). Try doing that with monolithic kernels!

      Obviously there's still testing of the user-level services, but at least now you have confidence that you won't have reliability issues originating from supervisor mode. This is similar to the guarantees you get with static typing; I'm sure you'd agree that there is value in static typing in eliminating several classes of bugs. So it is with microkernels. With proper microkernel primitives, you can have further guarantees.

    23. Re:Tanenbaum gets a failing grade by Anonymous Coward · · Score: 0

      That's not a very good troll. So 70% of the code is drivers for every supported computer configuration on 4+ platforms. What percentage of the total hardware support do you have in your machine? You have a christmas tree of USB hubs with every device attached? Some super mobo with 5k PCI slots? The parent poster said "in a running kernel", and I *assume* you can read if you try.

      "It's lovely that you could write a script to count lines"

      ROFL. find drivers -name '*.c' | xargs wc -l.
      You're arguing linux vs microkernel and you don't even know that simple shit? Wow.

      "loadable modules represent an evolution toward microkernel ideas"

      No they don't. Modules do nothing for security, stability, reliability, simplicity, etc. They are for dynamic configuration, which was never a bullet-point for microkernels anyway (outside of the appendix).

      Drivers usually take more code since they often have large tables in the code

      "...and you base that statement on...what? It's no more true of drivers than the rest of the kernel"

      Um, reading the f*cking driver and kernel source codes for years now. Duh.

      "fail to note that almost everything under fs/ and most of net/ is really driver code too"

      Not on linux. The drivers are charecter and block devices. The filesystems are device independent (thus not a drivers). Same with the network cards, the drivers are not in linux/net/. READ THE CODE BEFORE MOUTHING OFF LIKE A WANNABE RETARD.

      "if you could understand the numbers you were looking at before you make more false claims." ...from the person that thinks there only "might be" less driver code in any given kernel than exists for ALL SUPPORTED HARDWARE.

    24. Re:Tanenbaum gets a failing grade by be-fan · · Score: 1

      +1 Insightful :) I would have added a "Lisp or ML" to

      If the microkernel was combined with a safe language, like Java or C#

      but whatever.

      Are point about speed is absolutely spot-on. Memory-protection has a very significant overhead that most C folks don't really consider, that safe languages do not need. Let's consider the Athlon64. If you look at the die, you'll see that a very significant amount of real-estate is devoted to data and instruction TLBs, page-table walking hardware, etc. Get rid of all that, and you could easily increase integer execution resources by 33%. Then consider that even in the case of a TLB hit, memory protection increases the L1 cache latency by 50% (2 cycles for access, 1 cycle for TLB lookup). That's assuming you don't have to do a page-table lookup, which could cost a thousand cycles or more. Now, consider the overhead in the OS. Every system call now takes a couple of hundred clock cycles, because of the protection-level switch, instead of a dozen for a regular function call. Now, consider all that extra memory (up to several percent of your total RAM), and CPU time (from the page-scanning daemons) used up by the OS's VM.

      In comparison, what's the cost of a safe language? Some type-checks and range-checks, which, even when they aren't completely optimized-away, are cheap and easy to issue in parallel with regular code on a CPU with speculative execution.

      --
      A deep unwavering belief is a sure sign you're missing something...
    25. Re:Tanenbaum gets a failing grade by be-fan · · Score: 1

      You mean using seperate memory spaces is slower than writing all your apps in an interpreted language?

      There is no reason a safe language needs to be interpreted. Java and C# aren't (they are JIT'd), while C#, Lisp, ML (and a host of others), are usually or can be native-compiled.

      If it is true, then you would have to put the interpreter(s) in the kernel so no one could ever run a C program.

      In a single-address space system, the kernel ceases to have any particular significance. In a system designed for safe langauges, you wouldn't need an interpreter for safe languages, but you would need one for C.

      I think we just need faster context switching.

      That's like saying "I just think air resistance needs to be lower". Superscaler CPUs have lots of context that needs to be saved. The more powerful the CPU, the more complex it will be, and the more context it will need to save on a switch.

      --
      A deep unwavering belief is a sure sign you're missing something...
    26. Re:Tanenbaum gets a failing grade by Anonymous Coward · · Score: 0

      My, you're a pompous ass, aren't you?

  30. The USENET Post by zaguar · · Score: 1
    --
    "Sure there's porn and piracy on the Web but there's probably a downside too."
  31. Where does he get the time... by JanMark · · Score: 1

    Imagine professor Tanenbaum's workload, he is close to a regular visitor on slashdot, remember
    this story, and this one?

    --
    -- (:> jms cs.vu.nl (_) --"---
    1. Re:Where does he get the time... by AlXtreme · · Score: 1
      ... and every time our faculty gets pummeled. Basterds, all of you!

      Oh well, at least this time there wasn't a cs.vu.nl link in the post *content with Guillaumes & Steen's Globule finally getting a stress-test, burn burn burn...*

      I for one am happy with the new Minix release. Finally emacs. Finally Minix could actually be useful...

      --
      This sig is intentionally left blank
  32. Recollections by awol · · Score: 4, Interesting

    I was "there" when Andy and Linus had their first "ding dong". I was doing an OS/Design undergraduate (300 level) course at the time using the AT book and MINIX as the tool through which we had to implement changes to the scheduler. The book was excellent, MINIX was pretty cool but more importantly it was an educational tool to allow us to delve into the guts of an operating system and play around with it. It was so accessible and relatively easy to do, certainly compared to anything else available at the time.

    Cruising the newsgroups was pretty much the done thing at the time and comp.os.minux was pretty high on my list for obvious reasons. Saw this stuff happening at the time and, knowing that AST was always pretty direct was entertained by the whole flame war thing. Anyway my point is that AST saw MINIX as a OS theory educational tool and Linus saw it as too defective to be even that and as such Linux was better. Funny, I agree with them both, kinda. I could never have kernel hacked Linux like I did MINIX at the time and MINIX could never have become my primary desktop at home like it is now. I guess they were just talking at crossed purposes even then. Pretty much standard flamewar ;-)

    --
    "The first thing to do when you find yourself in a hole is stop digging."
    1. Re:Recollections by i_am_not_a_bomba · · Score: 2, Funny
      Cruising the newsgroups was pretty much the done thing at the time

      Were you wearing an onion on your belt?

    2. Re:Recollections by Anonymous Coward · · Score: 1, Funny

      I hear that was the style at the time.

  33. Documentation? Hmm, time machine not included by mikiN · · Score: 1

    Frim the Minix 3 site:

    The main documentation for MINIX 3 is the book

    Operating Systems: Design and Implementation 3/e by Andrew S. Tanenbaum and Albert S. Woodhull, Prentice Hall, 2006


    Too bad they don't list one of those handy prepaid 2-time-use time machines to buy and actually get the book...guess they're out of stock in the 26th Century.

    --
    The Hacker's Guide To The Kernel: Don't panic()!
  34. Tannenbaum still ahead! by Vo0k · · Score: 4, Funny

    See? It's Minix 3 already, while Linux is still in 2.x! ;)

    --
    Anagram("United States of America") == "Dine out, taste a Mac, fries"
  35. Do I have to buy another book for this version? by jvj1 · · Score: 1
    Does that mean I have to buy another book. I already have the first two ;)

    I used to run Minix on my 386 when I was a student . Unfortunately, I couldn't get the source code easly with the 1st edition of the book. I think the publisher had the copyright and have to send them a postcard with $60 or something and they will send you a tape/or floppies. That is a lot of money for a student. But, somebody gave the source to me. And I was looking like the picture of the guy in front of the book, glued my face to my computer :)

  36. Would be nice if... by hey · · Score: 1

    Some genious would come up with a patch to micro-kernel-ise Linux.

    1. Re:Would be nice if... by MyHair · · Score: 2, Informative

      http://www.mklinux.org/

      Not sure how current it is, and it might be for 68000-based CPUs if I'm not confusing it with another project.

    2. Re:Would be nice if... by Anonymous Coward · · Score: 0
    3. Re:Would be nice if... by Anonymous Coward · · Score: 0

      Apple did, oh, about 10-11 years ago. I used to run it on an old PowerPC 7500.

    4. Re:Would be nice if... by hawaiian717 · · Score: 1
      Reading the site a bit, MkLinux runs on PPC Macs, not 68k. Does look it's lost some steam, since the latest update to the main page was Sept 10, 2004, and the last update on the news page was Aug 11, 2002.

      For 68k Macs, Apple had A/UX for those who wanted a Unix implementation.

      --
      End of Line.
  37. Tanenbaum blew it by Anonymous Coward · · Score: 0

    The point for creating Linux was that Minix was not free for people to modify and spread, Tanenbaum wanted to keep it really nastily asshole private. There was no other choice but to create Linux.

    Tanenbaum was in a position to change computing history - after all Minix was already established when there was not yet a hint of Linux - but lost it all because of outright fucking single minded flat headed SELFISHNESS.

    1. Re:Tanenbaum blew it by Anonymous Coward · · Score: 1, Interesting

      You could not alter Minix directly because he wanted it to be a teaching aid and thus as clean and simple as could be. To say that he "wanted to keep it really nastily asshole private" is to do Prof. Tannenbaum a disservice, especially as he raised no objection whatsoever to Minix being passed around all over the place together with a bunch of "third-party" patch-sets.

    2. Re:Tanenbaum blew it by tchuladdiass · · Score: 2, Informative

      Actually, you could modify it. You just couldn't distribute modified versions of it. You could, however, distribute patches against the original code as much as you wanted.
      As to the reason for this, Andy T. had wanted to make the source widely available, but at that time (1990) there wasn't wide-spread access to the Internet (you had to be at a university that was on it, which many weren't, or you had to work for at a government shop). So the only choice was to have it published in the traditional maner (in this case, through Prentice Hall). But the publisher's at that time would only publish something if, and only if, they were exclusive. Andy fought hard to even get the publisher to allow "shadow copies" of the software (i.e., an instructor could give out copies to his students, or you could give out up to around 5 copies from a purchased copy).
      If the Internet was more in full swing at the time, where you didn't need a traditional publisher, then I'm sure that things would have been different.

    3. Re:Tanenbaum blew it by Anonymous Coward · · Score: 0

      I fail to get your point. He could have kept an educational version but allowed modifications.

    4. Re:Tanenbaum blew it by Anonymous Coward · · Score: 0
      I fail to get your point.
      Obviously; but that's probably because you're not particularly bright.
  38. VMware image. Was :live-CD by JanMark · · Score: 4, Informative

    Not only that, there is also a VMware image!

    --
    -- (:> jms cs.vu.nl (_) --"---
    1. Re:VMware image. Was :live-CD by bhsx · · Score: 1

      That's great, and it works; but I can't seem to be able to do anything useful with it, and can't find any documentation regarding the vmware image on the site. How do I install "links" from the site when wget isn't installed, for example? Any clues from the clueful?

      --
      put the what in the where?
    2. Re:VMware image. Was :live-CD by martin_b1sh0p · · Score: 1

      How about something even easier, what's the username/passwd for the vmware image? I'm sure I should be RTFM somewhere but it's easier to just ask on slashdot :-)

    3. Re:VMware image. Was :live-CD by ezzzD55J · · Score: 1
      That's great, and it works; but I can't seem to be able to do anything useful with it, and can't find any documentation regarding the vmware image on the site. How do I install "links" from the site when wget isn't installed, for example? Any clues from the clueful?

      Good question. What does one do with an operating system? Well, it has a compiler :). If you have networking working you can install packages with the 'easypack' script. That uses 'urlget' to retrieve the packages, compiles them, and installs them.

  39. Educational standards on Slashdot... by MosesJones · · Score: 5, Interesting

    His bio so in terms of why he gets to grade Linux as an F (IMO he was right, its improved since but it was poor, SMP, size of kernel, modularity, the only advantage was that NT and Windows scored a "Not Classified") its because he managed to understand Operating system design to such a level that his work was the BASIS from which Linus was "inspired".

    Minix and his work are key reference works in writing pretty much any OS and his work in computer networking and distribution in paticular are top notch. His stuff is very much NOT Ivory Tower (I speak as someone who has had to do bespoke OS work) and very practical way to build operating systems and overcome networking challenges. Heard of the OSI model for networking? Most of the rest of us have heard of it thanks to Andy's work, because we couldn't afford the official reference from ANSI/ISO.

    Out of interest what is you have done?

    --
    An Eye for an Eye will make the whole world blind - Gandhi
    1. Re:Educational standards on Slashdot... by rolfwind · · Score: 1
      I am less interested in why he gets to grade Linus anything versus why he would. I read the entire exchange between the two and I came out thinking that the F was because Linus and him diverged on fundamental questions about how one should approach designing an operating system - not that Linus himself lacked understanding (at the time) about the issues nor that he didn't put in his own effort. This is not how anybody should be graded - it'd be like a liberal political science professors grading his conservative students with F- or the other way around.

      But since Tanenbaum and Linus weren't actually teacher/student this matters very little.

      Out of interest what is you have done?


      And what have you done monumentally? Let's keep this apples to apples here - Tanenbaum vs. Linus if you want to devolve it to that level of debate.

      I'm more interested in real world results than theoretically conceptions from years ago that haven't bought in anything yet......

      BTW, I'm not trying to belittle the man as much as wonder why good sounding theoretical OSes should be upheld in the classroom instead of tested practical ones - once the students get into the real world OS designing, assuming they ever do, perhaps they would be better prepared by studying a successful real world OS.

      If you want simplicity, introduce them to DOS or amiga. If Microkernel is superior, prove it first in some way.
    2. Re:Educational standards on Slashdot... by idlake · · Score: 1

      system design to such a level that his work was the BASIS from which Linus was "inspired".

      Linus may have been "inspired" to create Linux by the existence of MINIX, but MINIX cannot be said to be the "basis" for Linux. In fact, Tanenbaum's work represents an approach to OS design that UNIX was originally created in reaction to.

      His stuff is very much NOT Ivory Tower (I speak as someone who has had to do bespoke OS work) and very practical way to build operating systems

      Well, then maybe you can give examples of significant contributions that Tanenbaum has made to systems like UNIX, Linux, Windows NT, Darwin, MPI, PVM, or other major operating systems or distributed programming systems in common use.

      (And, no, OSI and writing some nice textbooks, don't count.)

    3. Re:Educational standards on Slashdot... by Anonymous Coward · · Score: 0

      1. Unix predates Minix by quite a lot. How is Unix a reaction to Minix, or to microkernels, for that matter?

      > Well, then maybe you can give examples of significant contributions that
      > Tanenbaum has made to systems like UNIX, Linux, Windows NT, Darwin, MPI, PVM,
      > or other major operating systems or distributed programming systems in common use.
      >
      > (And, no, OSI and writing some nice textbooks, don't count.)

      Doesn't count?

      Why not?

      Teaching many of the people who went on to create much of the OS work you cite above
      doesn't count? Did your teachers contribute nothing to what you've done?

      Personally, I think AT wrote some of the best textbooks I've ever read. Why is this
      a non-accomplishment in your book?

      Regardless of whether you are in a position to judge or not (and most of us aren't),
      by any reasonable measure, AT will be remembered as an influence in OS design when
      we are long gone.

      Best wishes,
      -greg

    4. Re:Educational standards on Slashdot... by Anonymous Coward · · Score: 0

      1. Unix predates Minix by quite a lot. How is Unix a reaction to Minix, or to microkernels, for that matter?

      Please re-read what I wrote. UNIX was a reaction to the excesses of Multics; I view Tanenbaum in the Multics tradition of infatuation with architecture, features and complexity.

      Why not?

      Because textbooks, however well written, don't represent original work by the textbook author. Hence, software based on the textbook is not necessarily software based on the author's research. So, if you have examples of where Tanenbaum's original research found its way into widely-used operating systems and distributed programming systems, please share them.

      Regardless of whether you are in a position to judge or not (and most of us aren't)

      Operating system design isn't some abstract art form, it is there to solve real-world problems for real-world users. Unlike other new operating systems, Minix3 (and Tanenbaum's other work) fails to address the issues and problems I have with Linux, NT, or UNIX, and therefore I consider it useless. That is very much a judgement that I am in a position to make, just like I'm in the position to determine whether a Mack truck or a Ford Focus is a better vehicle for me.

    5. Re:Educational standards on Slashdot... by gammoth · · Score: 1
      I'm more interested in real world results than theoretically conceptions from years ago that haven't bought in anything yet......

      Then you'd be interested to know that field theory was developed by Evariste Galois http://en.wikipedia.org/wiki/Evariste_Galois/ in the 1800s. Galois studied abstract algebra precisely because he believed it would never have any practical application. However, the CDs and DVDs of today would not work without the error detection/correction techniques based on field theory. I think it's premature to be deciding the quality and impact of Tannenbaum's academic work.

      I'm a big Linux fan, and a big Linus fan. It's a great story, and Linus has had a huge impact on computing. However, from what I know, Linus has a few responsibilities other than coordinating Linux developement. Tannenbaum, on the other hand, has done original research, written several books, and taught at least one univeristy course. Not bad by any measure.

      Two more things. One, Linux is the result of the efforts of dozens if not hundreds of great programmers around the world. Two, don't confuse popularity with quality. Linux is great--for a work station. If you're running a server exposed to the internet, you'd be better off running Open BSD.

      Tannenbaum may have failed to call how computing would take shape. However, I can help but believe we'd be better off if his predictions of RISC architectures and micro-kernels, particularly the micro-kernels, had come to be.

    6. Re:Educational standards on Slashdot... by colinrichardday · · Score: 1

      But even Tanenbaum would have to give Linus an A in Cat Herding.

    7. Re:Educational standards on Slashdot... by Anonymous Coward · · Score: 0

      Tanenbaum's textbooks are among the most widely used and highly regarded. No serious computer scientist should miss these (I am nearly sure Linus didn't). Between both William Stallings and Tanenbaum you will have learnt everything you would ever need and/or want to know about Systems software.

      Computer Networks, Fourth Edition ISBN: 0130661023
      Distributed Systems: Principles and Paradigms ISBN: 0130888931
      Operating Systems: Design and Implementation ISBN: 0136386776
      Structured Computer Organization ISBN: 0131485210
      Modern Operating Systems ISBN: 0135881870

    8. Re:Educational standards on Slashdot... by Anonymous Coward · · Score: 0

      Two more things. One, Linux is the result of the efforts of dozens if not hundreds of great programmers around the world. Two, don't confuse popularity with quality. Linux is great--for a work station. If you're running a server exposed to the internet, you'd be better off running Open BSD.

      Have you ever seen what an OpenBSD system (and FreeBSD for that matter) can do to your network when it crashes? Your entire network is toast thanks to the arp floods they generate.

      Linux on the other hand has never ever done that. When the box crashes, it does not take out others too.

      I have managed clusters of Linux servers exposed to the Internet and so long as you don't use flaky hardware it is pretty much stable. I have seen running times approaching a year without a crash if there are no hardware related problems. Some Linux fan.

      Linux is good for both servers and workstations.

  40. It's all BSD licensed by david.given · · Score: 4, Informative
    It's worth pointing out that one of Minix's great selling-points is that it's all BSD licensed --- including the tool chain. It doesn't use gcc by default; its native compiler is the BSD licensed Amsterdam Compiler Kit.

    This makes it, as far as I know, the only completely BSD licensed Unix-like operating system in the world. Even the big BSDs can't claim that, as they all rely on gcc.

    I was in on the Minix beta testing. It's actually extremely impressive. It's quite minimalist; most of the shell commands are pared down to their bare minimum --- for example, tar doesn't support the j or z flags --- and it tends towards SysV rather than BSD with things like options to ps. It runs happily on a 4MB 486 with 1GB of hard drive, with no virtual memory, and will contentedly churn through a complete rebuild without any trouble whatsoever. Slackware users will probably like it.

    Driver support isn't particularly great; apart from the usual communications port drivers, there's a small selection of supported network cards, a FDD driver, an IDE-ATA driver that supports CDROMs, and a BIOS hard disk driver for when you're using SCSI or USB or some other exotic storage. The VFS only supports a single filesystem, MinixFS (surprise, suprise!) but allows you multiple mountpoints. In order to read CDs or DOS floppies you need external commands.

    There's no GUI, of course.

    As a test, as part of the beta program, I did manage to get ipkg working on it. This required a fair bit of hacking, mostly due to ipkg assuming it was running on a gcc/Linux system, but it did work, and I found myself able to construct and install .ipk packages --- rather impressive. Now the real thing's been released, I need to revisit it.

    Oh, yeah, it has one of the nicest boot loaders I've ever seen --- it's programmable!

    1. Re:It's all BSD licensed by starseeker · · Score: 1

      That's actually almost as interesting as the OS itself - I take it from your comment it can build itself? A completely separate toolchain from the normal Linux toolchain which is also minimalist and BSD licensed... wow. Is minix3 actually something you could scale up to "real world" usage or does its focus on being a teaching OS sort of limit that?

      --
      "I object to doing things that computers can do." -- Olin Shivers, lispers.org
    2. Re:It's all BSD licensed by Skjellifetti · · Score: 2, Informative

      It runs happily on a 4MB 486 with 1GB of hard drive, with no virtual memory, and will contentedly churn through a complete rebuild without any trouble whatsoever.

      Must be a lot of added bloat in there. Minix 1.5 used to run very happily on a PC XT w/ 640K RAM and a 40 MB disk. It would run on a minimal machine w/ as little as 256K RAM and 2 360K floppies. I haven't booted it in a century or so, but I still have an XT with Minix installed on it and a box of 20 or so 360K floppies with binaries and source.

      In fact, the lack of 386 memory management mode in Minix was one of the prime reasons that Linus started writing Linix. Tanenbaum was very reluctant to add features such as 386 mode and swapping. And IIRC, the Minix version on my XT did not even have a hard drive boot loader and required a 360K floppy disk to boot.

      One other point that I always wondered about w/ Minix was the security claims that Tanenbaum made for Minix 1.5. Again, IIRC, he offered a Dutch dollar for any new security bugs found. This always amused me since the 8088 has no memory management security and it is therefore trivial to write multitudes of user programs that could conquer the world. I don't suppose those counted, though. I assume that a 386 version that is running in 386 mode really is secure and not just pretend secure like 1.5.

    3. Re:It's all BSD licensed by david.given · · Score: 1
      That's actually almost as interesting as the OS itself - I take it from your comment it can build itself? A completely separate toolchain from the normal Linux toolchain which is also minimalist and BSD licensed... wow. Is minix3 actually something you could scale up to "real world" usage or does its focus on being a teaching OS sort of limit that?

      Yup. Log in as root, do cd /usr/src && make world install, and it'll rebuild and reinstall all libraries, binaries, the kernel, and the servers. A quick count (via find, wc -l and awk) reveals that /usr/src contains some 12000 lines of code.

      As for real-world usage --- if you'd care to define the term, I'd comment. Currently Minix lacks ssh (because OpenSSL depends on perl for its build process, which Minix doesn't have, and the libtomcrypt-based ssh implementation requires 64-bit int support, which the ACK doesn't have, and I haven't got gcc up and running yet), so I wouldn't use it for any heavy internet-related applications; but it should work really well for embedded systems. It ought to rock on a Gumstix.

    4. Re:It's all BSD licensed by gstoddart · · Score: 1
      It's worth pointing out that one of Minix's great selling-points is that it's all BSD licensed --- including the tool chain. It doesn't use gcc by default; its native compiler is the BSD licensed Amsterdam Compiler Kit [sf.net].

      It's ironic that the reason Linus wrote Linux in the first place was because Tanenbaum's license precluded anyone else from distributing mods to Minix.

      Tanenbaum has now overcome a 15 year old mistake, but it's far too late to make a difference.

      While I'm sure this is good for educational purposes, it will continue to be useless for real world applications. An academics pipe dream, but nobody else really cares.
      --
      Lost at C:>. Found at C.
    5. Re:It's all BSD licensed by KenSeymour · · Score: 1

      You could, in fact, distribute mods to Minux. You just couldn't distribute the entire source of Minux with your mods.

      The license allowed patch file sharing, but each user had to have their own licensed copy of Minux source to run the patches against.

      --
      "We can't solve problems by using the same kind of thinking we used when we created them." -- Albert Einstein
    6. Re:It's all BSD licensed by assantisz · · Score: 2, Insightful
      Tanenbaum has now overcome a 15 year old mistake, but it's far too late to make a difference.

      What the hey are you talking about? Minix is still a very popular operating system for teaching OS design principles. Why would you ever get the idea that Minix is supposed to be a Linux/UNIX/Windows/whatever killer? It was never designed to be anything bigger than an academic excercise. Never. Period.

    7. Re:It's all BSD licensed by Anonymous Coward · · Score: 0

      grub is kinda programmable too.

    8. Re:It's all BSD licensed by Anonymous Coward · · Score: 0

      How does it help to have a compiler licensed under BSD instead of under GPL??

  41. /.'ing... by packman · · Score: 1

    >> Disclaimer: I am the chief architect of Globule, the experimental content-distribution network used to host www.minix3.org /.'ing is a great way to test your network isn't it? :D

  42. Software? by Jacek+Poplawski · · Score: 2, Insightful

    But how mature and how usable this OS is?
    What about software for Minix?
    On website there is info about packages - gcc, vim/emacs, old Python, no ncurses, no X... What can I install (by compiling) on Minix and what is not possible and why?

  43. Flames and Criticism by VincenzoRomano · · Score: 1

    We all hope in a better rivalry between Andy and Linus.
    They are both great minds: there can be much more value in their cooperation than in falming each other!

    --
    Maybe Computers will never be as intelligent as Humans.
    For sure they won't ever become so stupid. [VR-1988]
  44. Device drivers: Andrew is living on denial. by MROD · · Score: 5, Interesting

    For example, each device driver runs as a separate user-mode process so a bug in a driver (by far the biggest source of bugs in any operating system), cannot bring down the entire OS. In fact, most of the time when a driver crashes it is automatically replaced without requiring any user intervention, without requiring rebooting, and without affecting running programs.

    This is all well and good until the crashing device driver locks the system bus or grams an NMI etc. And what if the device driver in qestion is the one accessing the disk? How does the microkernel recover from that one when it can't access the drive the device driver is sitting upon?

    I can see where his thought processes are coming from, but I still think he lives in Computer Science Heaven, I'm afraid, where all hardware is mathematically perfect and I/O never happens (as it's not mathematically provable).

    In the real world device drivers hardly ever crash the system 'cos they're kernel mode, they crash it because the hard-hang the system or denigh the kernel the resources to dig itself out of the hole. Neither of these change by moving the code into user space.

    --

    Agrajag: "Oh no, not again!"
    1. Re:Device drivers: Andrew is living on denial. by TA · · Score: 2, Interesting
      > And what if the device driver in qestion is the one accessing the disk? How does the microkernel recover from that one when it can't access the drive the device driver is sitting upon?

      The web page says that you have to keep a copy of the driver in RAM ...! The whole reincarnation concept is simply a gigantic hack and nothing else.

    2. Re:Device drivers: Andrew is living on denial. by MROD · · Score: 1

      By the way, please ignore the attrocious spelling and typing today.

      Here's how to patch my posting... :-)

      s/ on / in / if (/denial.$/);
      s/qestion/question/
      s/denigh/deny/

      --

      Agrajag: "Oh no, not again!"
    3. Re:Device drivers: Andrew is living on denial. by argent · · Score: 1

      In the real world device drivers hardly ever crash the system 'cos they're kernel mode, they crash it because the hard-hang the system or denigh the kernel the resources to dig itself out of the hole.

      In many cases you're right, and the ability of microkernels to dig themselves out of driver lockups is given more importance than it really warrants. However, it's not entirely irrelevant, as you're implying, nor is it the only way a microkernel design makes it easier to build a robust and fail-soft system.

    4. Re:Device drivers: Andrew is living on denial. by MROD · · Score: 1

      Oh, indeed, but the quote given gave the impression that it was a magic bullet which would stop device drivers bringing a system to its knees.

      Now, as a friend pointed out to me, having the device drivers as user-mode processes allows for easy maintenance and upgrade of the system on the fly. That's just one advantage (as well as enforcing a standard, thought through binary programming interface for drivers which Linux sorely lacks).

      --

      Agrajag: "Oh no, not again!"
    5. Re:Device drivers: Andrew is living on denial. by TummyX · · Score: 1

      That's true for core system drivers (like io) but there are many devices where a crash should not take down the system nor would it be a critical problem. USB devices, network adapters, sound cards (and other multimedia devices), input devices (mice/keyboards) could easily run in user mode and crash without really damaging the system.

      Besides being more reliable, user mode drivers would be a lot easier to write.

      IIRC, Microsoft has a user mode driver model in Vista for things like USB.

    6. Re:Device drivers: Andrew is living on denial. by Anonymous Coward · · Score: 0

      Oh, wow, you're right. I just thought of something else: If a user decides to take a gun and shoot a few holes in the motherboard, the microkernel doesn't recover from that either! Why bother even trying a solution that solves some of the problems if it can't solve all of them? Until someone invents an operating system that can withstand total hardware destruction, there's clearly no point in trying to improve anything.

    7. Re:Device drivers: Andrew is living on denial. by MROD · · Score: 1

      Oh yes, I agree. I'm not saying that it's a bad idea, merely that the way it was presented was a misreprisentation of the benefits.

      It's always a good idea to compartmentalise code as much as possible so as to try to prvent bugs in one part killing the whole thing.

      --

      Agrajag: "Oh no, not again!"
    8. Re:Device drivers: Andrew is living on denial. by MROD · · Score: 1

      Oh, I missed that bit. Even so, there is, of course the chance that the bug which killed the driver the first time will trigger its replacement's demise because of the same conditions applying.

      Of course, the OS could have two different drivers for each critical bit of hardware which were independently developed so that if one crashes the other gets loaded... but that silly. :-)

      --

      Agrajag: "Oh no, not again!"
    9. Re:Device drivers: Andrew is living on denial. by justins · · Score: 2, Interesting
      I can see where his thought processes are coming from, but I still think he lives in Computer Science Heaven, I'm afraid, where all hardware is mathematically perfect and I/O never happens (as it's not mathematically provable).

      If by "him" you mean Andy Tanenbaum you probably ought to give him the benefit of the doubt, as his position is being represented by some random slashdot person. Maybe just email him.
      --
      Now before I get modded down, I be to remind whoever might read this that what I am saying is FACT. - bogaboga
  45. no data by idlake · · Score: 1

    There is nothing to "dispute" since that's not even a meaningful claim. People have built very unreliable microkernels and very reliable monolithic kernels.

    So far, there is no data to support the idea that among the many variables that determine reliability (effort, programming language, architecture, testing, etc.), the microkernel/monolithic distinction makes any difference whatsoever.

    How can that be? Well, for example, microkernel architectures may complicate software development to the point where less time can be devoted to testing or where essential features can't be implemented at all and the project fails altogether.

    1. Re:no data by harlows_monkeys · · Score: 1
      There is nothing to "dispute" since that's not even a meaningful claim. People have built very unreliable microkernels and very reliable monolithic kernels

      The difference is that you can build a microkernel and prove it is reliable, secure, meets performance specifications, etc. No one has been able to do that for a monolithic kernel.

      It is no coincidence that if you want a kernel that can be certified at EAL 7, you have to go with a microkernel.

    2. Re:no data by idlake · · Score: 1

      The difference is that you can build a microkernel and prove it is reliable, secure, meets performance specifications, etc. No one has been able to do that for a monolithic kernel.

      Come on, you yourself must realize that that assertion is preposterous; numerous kernels in applications like smart cards have been formally verified.

      (Let's not even go into all the theoretical and practical problems associated with using proof techniques for attempting to establish reliability and security.)

  46. First Retarded Slashbot Post! by Anonymous Coward · · Score: 0

    MINIX 3 released. Is this the beginning of the end of Linux?

  47. Embedded OS... by Florian · · Score: 1

    Minix v3 looks like a much improved system, with large memory addressing and software like Emacs, vim, Python, Perl and gcc included. However, resource usage has become more like Linux and *BSD in the process, too. While Minix v2 happily ran with 2 MB RAM (I actually used it on a 386sx laptop), Minix v3 requires 8 MB, better 16 MB RAM. This is pretty much the same as NetBSD, an arguably more versatile and mature embedded OS. - Of course, I am aware that Minix is primarily an educational system and the microkernel/driver architecture has interesting hack value. Nevertheless, it seems that Minix' niche has rather shrunk than grown with the direction the project has taken...

    --
    gopher://cramer.plaintext.cc http://cramer.plaintext.cc:70
  48. the irony of it all! by marafa · · Score: 0
    "MINIX 3 is a new open-source operating system designed to be highly reliable and secure."
    if it hadnt been for tanenbaum refusing to give the source code to linus to study, linus wouldn't have been galled into making his own operating system. and now 15 years later minix is released as open source

    the irony of it all!

    --
    _ In Egypt Networks: Network Solutions with a Twist
    1. Re:the irony of it all! by argent · · Score: 1

      if it hadnt been for tanenbaum refusing to give the source code to linus to study

      That didn't happen.

      The reasons Linus implemented Linux rather than improving Minix are far more complicated than just the license on Minix, and in any case the license on Minix was far less restrictive than you imply.

    2. Re:the irony of it all! by slashflood · · Score: 1

      The reasons Linus implemented Linux rather than improving Minix are far more complicated than just the license on Minix

      So why don't you tell us the reasons?

      It was just one reason: The terminal emulation of Minux was crap, so he wasn't able to work remotely on the campus servers. He decided to write his own terminal program for Minix. It was already multi-threaded, handling modem->display and keyboard->modem. Just in a period of four months, he created a first bootable operating system out of his terminal application.

    3. Re:the irony of it all! by argent · · Score: 1

      So why don't you tell us the reasons? [...] It was just one reason...

      That's like saying the only reason UNIX was written was to test a file system.

      You described how. You didn't describe why. After all, I wrote a terminal program for DOS back in 1985 because all the terminal emulators on DOS were crap, and I wasn't able to work on both the VMS and RSX systems at Ensun. Somehow I managed to avoid having that application expand into an operating system... so it seems to me that there's probably a little more involved in the creation of Linux than Linus' frustration with a terminal emulator.

      Or maybe I simply have more self-control. :)

    4. Re:the irony of it all! by Anonymous Coward · · Score: 0

      That's like saying the only reason UNIX was written was to test a file system.

      Wasn't the reason UNIX was written was over a videogame?

    5. Re:the irony of it all! by argent · · Score: 1
      Wasn't the reason UNIX was written was over a videogame?

      No, UNIX already existed when Space Travel was ported to run under it. ST ran standalone on the PDP-7, and was never ported to the PDP-11.

      Because Ken was now familiar with the '7 and knew he could use it as much as he wanted, the first version of Unix was written on this PDP-7. So ST came before Unix, but doing ST led him to a place in which he could write the first version of Unix.


      The reason UNIX itself was written was because Bell labs was pulling out of the Multics project, so Ken wasn't able to work on his ideas about operating systems in that environment. The first version of UNIX was pretty much just a REALLY simple ancestor of the shell... enough to test the file system he was working on.

      The UNIX file system was really revolutionary back in 1969 and 1970. It doesn't seem that way today, with virtually every operating system developed since 1980 or so following the UNIX model, but in the '60s and '70s it was normal to deal with files as an array of records, with each record having a type and size and internal structure that was usually (but not always) the same throughout the file. UNIX presented you with a file that had no structure. It was just an array of bytes, and any structure was imposed over this by the application. It was this concept... a kind of distillation of CTSS and the memory-mapped files of Multics... that was started bringing the UNIX environment together.

      But if Bell labs hadn't needed a new computing platform to replace Multics it's doubtful it would have gone much further than that... Space Travel or no.
  49. Microkernel Question? by Anonymous Coward · · Score: 0

    Isn't debugging a microkernel suppost to be a bitch when compaired with a monolithic kernel ?

    My limited understanding of what a microkernel is, it makes use of semaphore messages which can lead to problems in diagnosing and fixing race condition bugs.

    Is this correct?

    G.

  50. HURD Is Out by RAMMS+EIN · · Score: 1

    This system is pretty close to what the HURD should have become. The core is a simple message-passing infrastructure, and everything else is implemented as a daemon. This makes it easy to write and debug drivers. One thing that is still lacking (AFAIK) is a VFS, but that's being worked on.

    --
    Please correct me if I got my facts wrong.
  51. user mode device drivers by soldack · · Score: 3, Interesting

    I have done my share of kernel programming and I have always thought that it is pretty horrible that simple device driver bugs can take down the system. Almost all of Windows' Blue Screens are from bad third party drivers. Almost all of the oopses I have seen on linux are from device drivers for extra hardware (I mean drivers not for core common O/S features). On linux device driver debug still seems to be horrible; on Windows it is considerably better but still not as good as application debug.
    With common user systems as cheap and fast as they are now, do user mode device drivers make sense? Is the performance worth giving up for the stability? Check out Microsoft's User-mode Driver Framework approach. Here is an old linux journal article on the subject. Does anyone know of other interesting examples of user mode device drivers on any operating systems?

    --
    -- soldack
  52. Slapping a nice GUI by Anonymous Coward · · Score: 0

    Does Minix have a framebuffer like Linux? Then it would be possible to implement DirectFB http://www.directfb.org/ on top of it. This would give me more reason to renew my wyoDesktop http://wyodesktop.sf.net/ project.

    1. Re:Slapping a nice GUI by Anonymous Coward · · Score: 0
      wyoDesktop is an effort to create a graphical desktop environment (desktop GUI) where an ordinary user immediately feels comfortable through the use of a well designed and consistent look and feel. Becoming comfortable and being consistent also means to strive for a minimal amount of beauty.

      Looks like windows 3.1, lol.

  53. POSIX Compliance by RAMMS+EIN · · Score: 1

    A friend of mine has been trying to get a POSIX test suite on MINIX, and met with mixed success. Apparently, available POSIX test suites tend to rely on features that aren't in POSIX (such as gcc extensions), require optional features to test required features, and/or be severely limited in scope.

    In the end, I believe he got some results, but no definitive yes or no on POSIX compliance.

    One of the features that isn't supported is the MSG_PEEK flag on recv(2) (I know, because my webserver, muhttpd, uses it). However, this flag may not have been present in the version of POSIX that MINIX aims to comply with...

    The bottom line is that a lot of stuff will need porting to run on MINIX, but this doesn't seem to be a very difficult job.

    --
    Please correct me if I got my facts wrong.
  54. One figure missing in this debate... by Anonymous Coward · · Score: 0

    ...and he is a Chuck Moore.

    "OS obsolete" - he says :)

  55. OS for mobile devices ? by S3D · · Score: 1

    Sounds like a great OS for mobile devices - PDA, cell phones, camera etc. Stable, small, OS not crushing if some driver fail. Why it was never used for mobiles ?

  56. Minix is from the future by Anonymous Coward · · Score: 0

    Check http://www.minix3.org/license.html:
    Copyright (c) 1987,1997, 2006 , Vrije Universiteit, Amsterdam,
    indeed the future of OS.

  57. Use of BSD by jhines · · Score: 1

    AFAIK, OS X uses the BSD environment, over their own kernel. The environment is things like compiler, linker, lib, shell, cp and all those other little utilities we all know and love.

    1. Re:Use of BSD by Joehonkie · · Score: 1

      It runs over the Mach microkernel, just like NeXT did.

  58. Well, i think too... by ratta · · Score: 1

    that micro-kernels are more "reliable" than monolithic kernels. The problems come with the low performance, but also in the design phase when you have to decide which layers are above which layers. Ie: should the VM (Vistual Memory) be stacked above VFS (Virtual File System) or VFS above VM? VFS requires VM for file m-mapping, VM requires VFS for swap. I'd like to know how Tanenbaum solved this problem :)

    --
    Wondering why i am doing so strange posts? I am trying to get a "+5,Flamebait" or "-1,Insightful" rating.
    1. Re:Well, i think too... by Anonymous Coward · · Score: 0

      If what you say is true, isn't the answer obvious? Make the Virtual Memory and Virtual File System implemented in the same module.

    2. Re:Well, i think too... by vidarh · · Score: 1

      Why do you think they have to be implemented in a stacked way? There's nothing stopping the VFS and VM modules from co-existing in parallel and have both using eachothers services.

    3. Re:Well, i think too... by argent · · Score: 1

      Microkernels don't have any more problems deciding how to implement paging through the file system than monolithic kernels... remember that UNIX implementations didn't support paging to a file until well into the '80s.

  59. Microkernel and GUI by Anonymous Coward · · Score: 0

    It's much easier to write a microkernel since you simply offload all the needed code to build for a complete system and possibly just forget to implement all the offloaded code. Who is using a shell only system these days even just for operating system classes? It's too easy to implement a microkernel without a GUI possiblity. It leave the taste of "not being able" to implement a GUI. At least as long as there isn't a GUI driver, there is _no_ prove!

    I'd really like to see a microkernel with a framebuffer driver, something like DirectFB http://www.directfb.org/.

  60. No source? by Markus+Registrada · · Score: 2, Interesting

    I didn't find a tarball of source code, just the ISO image. When I loopback-mount the ISO image, I don't find anywhere near 80M of stuff. Is the source on the ISO image?

    1. Re:No source? by david.given · · Score: 2, Informative
      I didn't find a tarball of source code, just the ISO image. When I loopback-mount the ISO image, I don't find anywhere near 80M of stuff. Is the source on the ISO image?

      Yes, it is --- it's on a Minix filesystem tucked away at the top of the ISO filesystem. If you boot the CD, you'll get a complete Minix LiveCD based system, with all the source on it.

      If you want to access it from Linux you'll need to persuade Linux to parse the partition table on the CD, which it normally won't do --- the easiest way to do this is to dd the whole lot off the CD and onto a scratch drive. Linux will then see the partition table, and you'll be able to find and mount the Minix filesystem.

  61. AT LEAST ! GNU/HURD KILLER ! by Anonymous Coward · · Score: 0

    At least we have modern and very minimalistic UNIX OS !! :D :D :D
    And now i have choice to resurect my 386sx with MODERN UNIX [not some old linux / netbsd verions]

    i hope that with MINIX 3 gnu/hurd will finally DIE !!! :D

  62. agreed 100% by idlake · · Score: 3, Interesting

    I agree 100%. And there has been excellent prior work in that area, with fault isolation in single-address space kernels; experiments suggest that single-address space approaches are significantly faster. And it doesn't even have to be Java or C#; languages like Modula-3 or Object Pascal are far safer than C and can get by with a tiny runtime. Heck, even consistent use of C++ for writing kernels would be better than what people are doing now, despite the numerous problems that C++ has.

    It is just astounding to me that while anybody else would be laughed at if they tried to write a modern, complex application in ANSI C, operating system designers are somehow considered special, as if concepts like "abstraction", "error handling", and "runtime safety" didn't matter for kernels that are millions of lines big.

    1. Re:agreed 100% by Salamander · · Score: 1
      there has been excellent prior work in that area, with fault isolation in single-address space kernels; experiments suggest that single-address space approaches are significantly faster.

      Yes, and some of the more performant microkernels do share address spaces. Don't confuse microkernel design with microkernel implementation. It's entirely possible to adhere to the design principles of a microkernel, perhaps even prototype or test using separate address spaces, and then implement a version in which components run in a single address space - with or without special provisions made to isolate each module from memory faults caused by another. It's still not the same as a monolithic kernel in which every component can and often does twiddle others' data, regardless of which language is used for its implementation.

      --
      Slashdot - News for Herds. Stuff that Splatters.
    2. Re:agreed 100% by idlake · · Score: 1

      Don't confuse microkernel design with microkernel implementation. It's entirely possible to adhere to the design principles of a microkernel, perhaps even prototype or test using separate address spaces, and then implement a version in which components run in a single address space

      Perhaps you would care to define what you consider those "microkernel design principles" to be? Be sure to contrast them against object oriented programming, active objects, and message passing.

      It sounds to me increasingly like "microkernel" to you means "a kernel implemented in ANSI C that uses a hand-crafted message passing object system".

      It's still not the same as a monolithic kernel in which every component can and often does twiddle others' data

      Monolithic kernels written in languages like Java make it impossible for components to "twiddle" each other's data; they can only "twiddle" what they can access. Some languages make it impossible in principle to access data in other objects without calling a method.

      Conversely, microkernels frequently "twiddle" each other's data--they just do so by sending requests to do so. The effects and risks (race conditions, aliasing, etc.) are the same as calling a method, it simply happens to be a little less efficient in the microkernel.

    3. Re:agreed 100% by naasking · · Score: 1

      It sounds to me increasingly like "microkernel" to you means "a kernel implemented in ANSI C that uses a hand-crafted message passing object system".

      Not necessarily C, but any low-level language that gives the programmer direct control over representation and runtime (this is the only real requirement). So why not C++, or BitC?

      The defining characteristic of microkernels is a small set of kernel-implemented primitives upon which an entire system can be built in userspace. EROS/CapROS, and Coyotos have only one system call and a few kernel objects for instance.

    4. Re:agreed 100% by Salamander · · Score: 2, Informative
      Perhaps you would care to define what you consider those "microkernel design principles" to be? Be sure to contrast them against object oriented programming, active objects, and message passing.

      Oh, I get it. I'm supposed to distinguish microkernels from other things only in terms of aspects you dislike, allowing you to appropriate anything you do like for "your side" of the debate? Sorry, not falling for it. As I said earlier, both microkernels and OOP are variants of the same basic concept: modularity. Like one, like both. Hate one, hate both. Making arbitrary distinctions for the sole sake of hyping one and dissing the other is dishonest.

      Monolithic kernels written in languages like Java make it impossible for components to "twiddle" each other's data

      Then such a kernel's not very monolithic, is it? Idiot. What do you call that piece of code that takes care of loading classes and dealing with reflection and garbage collection and other forms of inter-component mediation and safety enforcement in your microkernel-less utopia, Mr. Smartass? Oh, right. It's a microkernel. Sheesh.

      Conversely, microkernels frequently "twiddle" each other's data--they just do so by sending requests to do so.

      Oh, so Java objects can't exchange messages, or implement trivial getter/setter methods? Yeah, right. The kind of twiddling you mention is trivially possible in any language or environment, whether it be C or Java or Linux or QNX. I've even written about that problem. . .twice, and both before you showed up to be educated. Attributing a problem only to one paradigm when it applies to both is, again, dishonest.

      You're just lucky I'm not charging you my usual hourly rate for being your own private tutor. You couldn't afford it, and will never be able to while you have more attitude than knowledge.

      --
      Slashdot - News for Herds. Stuff that Splatters.
    5. Re:agreed 100% by gammoth · · Score: 1

      Thank you, thank you, thank you, thank you.

      Thank you.
    6. Re:agreed 100% by idlake · · Score: 1

      The defining characteristic of microkernels is a small set of kernel-implemented primitives upon which an entire system can be built in userspace.

      I agree with that definition of microkernel, but "Salamander" apparently does not.

    7. Re:agreed 100% by naasking · · Score: 1

      I agree with that definition of microkernel, but "Salamander" apparently does not.

      I'm sure he agrees with that definition, but he's disagreeing with your assertions that the kernel as a managed virtual machine of some sort would be more practical and useful. While potentially an interesting direction for research, it does not at all seem feasible with current hardware. Well, current consumer hardware; high-end architectures have more exotic features which may make it possible.

      Like it or not, hardware page-level protection is the best we have, and microkernels are thus far the best way of exploiting this widely deployed architecture. Fortunately, page-level protection really is good enough for every purpose we need. In particular see CapROS and Coyotos for pure object-oriented operating systems (Actors message-passing syle with true capability security). I think you'll learn a lot from the papers written on EROS/CapROS.

    8. Re:agreed 100% by idlake · · Score: 1

      Your games with terminology don't change the fact that Tanenbaum made two specific design decisions in Minix3: he uses an intrinsically unsafe language and runtime with almost no built-in data abstraction facilities, and he relies on separate address spaces for fault isolation. Nobody has ever been able to demonstrate that those are good design decisions, and the repeated failure of that approach in real-world operating systems strongly suggest it is not.

      New kernels should be written in languages with better support for abstraction and fault isolation than ANSI C, and they should not rely on multiple address spaces for fault isolation.

    9. Re:agreed 100% by idlake · · Score: 1

      While potentially an interesting direction for research, it does not at all seem feasible with current hardware.

      Why not? Man operating systems have been implemented in languages with more safety and fault isolation features than C (languages like PL1, Modula-3, Oberon, ObjectPascal, Cedar/Mesa, Algol, Ada, Lisp, and Smalltalk). Fault isolation within a single address space can be provided in software via safe languages, safe runtimes, sandboxing via instruction rewriting, and certified compilers, to name just a few. And even if you want to use a full JVM or CLR, they are efficient and have footprints that ought to be perfectly acceptable for a modern kernel.

      I think you'll learn a lot from the papers written on EROS/CapROS.

      I doubt I would learn anything more from them than last time I read them...

      Coyotos for pure object-oriented operating systems (Actors message-passing syle with true capability security).

      Well, Coyotos at least looks like a far more worthwhile project than either Minix3 or EROS.

    10. Re:agreed 100% by naasking · · Score: 1

      Man operating systems have been implemented in languages with more safety and fault isolation features than C (languages like PL1, Modula-3, Oberon, ObjectPascal, Cedar/Mesa, Algol, Ada, Lisp, and Smalltalk).

      Agreed. I never said it had to be written in C or any other unsafe language. The only requirements are low-level control over representation, and strict control over the runtime.

      Fault isolation within a single address space can be provided in software via safe languages, safe runtimes, sandboxing via instruction rewriting, and certified compilers, to name just a few.

      I doubt very much that this would be acceptable on modern hardware. Greatest performance enhancements on current archiectures due to caches. JITC, instruction rewriting, etc. are cache killers. As of this time, runtimes in the kernel are simply infeasible because the technology just isn't there yet. Certified compilers, proof-carrying code, etc. is possible, but the implementations aren't here yet (Coyotos is implementing BitC).

      If you have some alternative design for a kernel or operating system which will mitigate the above issues, then why don't you be more specific and state it? Otherwise, we're just going to argue in circles since I have no idea what you're trying to demonstrate.

      I doubt I would learn anything more from them than last time I read them...

      Well, I think you should review the performance analyses, the identified bottlenecks and see how they apply to your ideas. There was a lot of good analysis done in EROS and in the L4 world.

      Well, Coyotos at least looks like a far more worthwhile project than either Minix3 or EROS.

      Well to each his own. CapROS/EROS can potentially deliver within two years but Coyotos is definitely further than that. I agree that it's a more promising architecture given it's being designed by the people who built EROS, but if you're looking for something more practical in the near future, look to CapROS.

    11. Re:agreed 100% by naasking · · Score: 1

      Man operating systems have been implemented in languages with more safety and fault isolation features than C (languages like PL1, Modula-3, Oberon, ObjectPascal, Cedar/Mesa, Algol, Ada, Lisp, and Smalltalk).

      As a little addendum, I'll just submit that C, C++ and Ada are probably the only languages with free compilers that can be feasibly used to build a microkernel at this time.

    12. Re:agreed 100% by be-fan · · Score: 1

      Like it or not, hardware page-level protection is the best we have, and microkernels are thus far the best way of exploiting this widely deployed architecture.

      Correction. Not "best we have" but "what we're stuck with". The "best we have" is using the optimizer technology developed for Lisp, Smalltalk, and now Java to make typechecks and rangechecks cheap, and allow programs to ditch the hardware-level "memory protection tax" that current CPUs are stuck with.

      --
      A deep unwavering belief is a sure sign you're missing something...
    13. Re:agreed 100% by be-fan · · Score: 1

      Certified compilers, proof-carrying code, etc. is possible, but the implementations aren't here yet (Coyotos is implementing BitC).

      I don't know what "technology" there needs to be. There are lots of native-code compilers that generate "safe" code. All that's required is some form of code-signing to guarantee that a program was compiled on such a compiler. Or, distribute applications in some intermediate-representation, then have them be compiled to machine-code, on a trusted compiler, at install-time.

      --
      A deep unwavering belief is a sure sign you're missing something...
    14. Re:agreed 100% by idlake · · Score: 1

      "Fault isolation within a single address space can be provided in software via safe languages, safe runtimes, sandboxing via instruction rewriting, and certified compilers, to name just a few." I doubt very much that this would be acceptable on modern hardware. Greatest performance enhancements on current archiectures due to caches. JITC, instruction rewriting, etc. are cache killers.

      All those techniques yield competitive performance to C in user space. Why do you think they wouldn't do so in kernel space?

      CapROS/EROS can potentially deliver within two years but Coyotos is definitely further than that.

      I don't think any of those systems will ever result in a practical OS; they were/are research projects. If you want some those features in a real-world system, you need to figure out how to bring them to Linux.

    15. Re:agreed 100% by Anonymous Coward · · Score: 0

      Languages converts human readable text to (virtual)machine instructions.
      Operating Systems abstracts (hardware)services.
      The hardware executes only assembler, any language, no matter how 'high' or 'powerful' or 'safer' is executed as a series of assembler sequences.
      It seems you have some misconceptions about software design and machine operation.
      High level 'protections' gets always executed on 'not protected' hardware.

    16. Re:agreed 100% by Anonymous Coward · · Score: 0

      High level 'protections' gets always executed on 'not protected' hardware.

      That is false. Tanenbaum specifically combines unsafe programming languages with the use of hardware protection in his operating systems. Other operating systems rely on fault isolation through language and software mechanisms and do not utilize hardware protection. That's a specific and very real design difference. I am arguing that Tanenbaum made the wrong design choice.

      Languages converts human readable text to (virtual)machine instructions. Operating Systems abstracts (hardware)services.

      It seems you have some misconceptions about the purpose of various software systems you use daily; yours is not an accurate description of the function of programming languages, compilers, or operating systems.

    17. Re:agreed 100% by scharman · · Score: 1

      At some point you have to write a memory manager.
      At some point you have to write a cpu scheduler.
      At some point you have to write a time interrupt handler. ...

      Most of the above you cannot write in a 'protected' language, because the mechanisms that provide you the 'protection' are not yet existant. Java/C#/etc can't provide resources, thread scheduling, etc etc etc without the above services. Unfortunately, unlike writing a compiler, bootstrap'ing an os to replace components is a lot nastier (and really not worth the effort).

      Whilst I also dislike C as a dinosaur language (not even support for basic abstraction let alone oo capabilities), it does not mean that "managed" languages are the solution for OS design. Managed languages are far from a panacea. (Geez, with a good profiler / memory checker, I don't mind doing my own memory management).

      Oh yeah, and to the people who *keep* saying managed languages are faster for various unspecified reasons, christ, just deal with it.. managed languages are slower.. sometimes only slightly, mostly significantly, and occasionally terribly.. life is hard..

      have a good weegend! :)

    18. Re:agreed 100% by naasking · · Score: 1

      I don't know what "technology" there needs to be. There are lots of native-code compilers that generate "safe" code. All that's required is some form of code-signing to guarantee that a program was compiled on such a compiler.

      I'll say it once again, the only requirement for a language to be used in a kernel is direct control of low-level representation, and direct control of runtime environment. Many languages do not provide this.

    19. Re:agreed 100% by naasking · · Score: 1

      All those techniques yield competitive performance to C in user space. Why do you think they wouldn't do so in kernel space?

      I'm speaking from the perspective of a microkernel when I'm arguing this, so perhaps that illuminates things for you. A small implementation with critical code paths that fits nicely within L1 cache are essential for high performance. Can you honestly tell me with a straight face that JITC techniques, garbage collection, and other high-level features are competitive with C for producing such code? Point me to a high-level language you think is usable in a kernel, ie. with all or some of your desired feature set, then show me where it gives you direct low-level control over memory layout and data structure representation, and control over the runtime.

      The only efforts I've seen in this regard are BitC, Nitro, and Cyclone (projects that actually have implementations that is). None of them are there yet.

      I don't think any of those systems will ever result in a practical OS; they were/are research projects.

      I suggest you read more about the history of EROS. It was initially designed as a direct reimplementation of KeyKOS, the first commercial timesharing operating system to support mutually suspicious clients. It's been used in ATMs and other mission-critical operations for decades. EROS has since improved on the KeyKOS design. There is absolutely no reason why CapROS could not become a practical system. There is nothing research-centric about EROS/CapROS except its unfinished nature.

    20. Re:agreed 100% by naasking · · Score: 1

      Not "best we have" but "what we're stuck with". The "best we have" is using the optimizer technology developed for Lisp, Smalltalk, and now Java to make typechecks and rangechecks cheap, and allow programs to ditch the hardware-level "memory protection tax" that current CPUs are stuck with.

      Without proof-carrying code or hardware support, ensuring memory protection at any granularity without implementing a full-blown virtual machine is impossible. There was a proposal a year or two ago outlining a low-level software segment protection scheme (for loading untrusted plugins, etc.), but the hardware isn't here yet (if it ever will be). Past architectures that had a protection bits per word were inferior either in performance or cost.

      A virtual machine in the kernel is simply infeasible at this point, so I'd rephrase it as "best we currently have at such a low-price point" if you want to be pedantic. See my other post on what is being done with better languages.

    21. Re:agreed 100% by idlake · · Score: 1

      Can you honestly tell me with a straight face that JITC techniques, garbage collection, and other high-level features are competitive with C for producing such code?

      Why not? What do you think people were using for writing operating systems before C and UNIX became popular with academics and a misguided generation of CS graduates? Of course, you do add a little bit of assembly code in a few places, like the scheduler, but if you are careful, you can keep that to below a few thousand lines. The rest can be entirely done in a HLL other than C. Don't get me wrong: C was a neat hack and great fun on a PDP-11, but it has never been either a well-designed language or a high performance language.

      As for JITs and GC, both of them are bonuses from a performance point of view. A well-implemented JIT gives you cross-module optimization and inlining even in the presence of dynamic loading, something potentially quite useful in a kernel. And a GC is not only less error prone than manual storage management, it is also more efficient.

      The only efforts I've seen in this regard are BitC, Nitro, and Cyclone (projects that actually have implementations that is). None of them are there yet.

      I haven't tried BitC or Nitro, but Cyclone's performance is pathetically poor. I think Cyclone has tried to stick too close to C.

      There is absolutely no reason why CapROS could not become a practical system. There is nothing research-centric about EROS/CapROS except its unfinished nature.

      But that's what I'm talking about. I mean, who is going to work on CapROS and who is going to bother using it? If I want capabilities, I can get them in Linux or BSD.

      No matter how badly C and C-based monolithic kernels may suck, the path towards better OSes is likely going to be incremental, starting from Linux or BSD: permitting the loading of modules written in other languages, adding a JIT, adding capabilities, etc.

      And if you believe in microkernels, then the path to making it happen is likely to be adding microkernel-like facilities to the Linux kernel. If microkernel designs are so great, then people will naturally start using those new microkernel facilities to add new drivers, file systems, etc.

    22. Re:agreed 100% by naasking · · Score: 1

      Why not? What do you think people were using for writing operating systems before C and UNIX became popular with academics and a misguided generation of CS graduates?

      You mean Lisp machines? That requires special hardware. All early operating systems were written in low-level languages, essentially assembler. C was among the first "portable assembly languages". Not the first, and perhaps not the best, but it clearly had some advantage if it won out over the rest.

      The rest can be entirely done in a HLL other than C. Don't get me wrong: C was a neat hack and great fun on a PDP-11, but it has never been either a well-designed language or a high performance language.

      C is barely a step up above assembler. You can't get higher performance than assembler. You can talk all you like about runtime profiling and optimizations, but the very nature of a microkernel means the code paths have already been highly tuned and minimized.

      As for JITs and GC, both of them are bonuses from a performance point of view. A well-implemented JIT gives you cross-module optimization and inlining even in the presence of dynamic loading, something potentially quite useful in a kernel. And a GC is not only less error prone than manual storage management, it is also more efficient.

      Perhaps you should re-read my post. From application-level programming perspectives, these features are well-motivated. From a microkernel perspective these features are ill-motivated, if feasible at all.

      Additionally, any sort of runtime environment in the kernel itself, any sort of state even runtime modification, means the kernel is now vulnerable to denial-of-service attacks. The point of reliability, security and fault isolation in microkernel designs is to minimize the attack surface, not expand it.

      But that's what I'm talking about. I mean, who is going to work on CapROS and who is going to bother using it? If I want capabilities, I can get them in Linux or BSD.

      No, you really can't. I hope you're not talking about so-called "POSIX capabilities". Those are nothing like real capabilities. I suggest you re-read that literature you said you've read, because capabilities and capability operating systems are far more powerful than anything you can ever do in Linux or BSD. The best you can do is implement Plan 9-style private namespaces, which get you part of the way there.

      No matter how badly C and C-based monolithic kernels may suck, the path towards better OSes is likely going to be incremental, starting from Linux or BSD: permitting the loading of modules written in other languages, adding a JIT, adding capabilities, etc.

      Or starting with a microkernel, and implementing a Linux/BSD compatibility layer. Like the one that existed for KeyKOS way back in the 80s which provided binary-compatibility with UNIX operating systems. Like L4Linux. Like Xen. Even drivers can theoretically have a Linux compatibility cradle, and I believe this is the direction CapROS will pursue.

      And if you believe in microkernels, then the path to making it happen is likely to be adding microkernel-like facilities to the Linux kernel.

      You can't. The best you can do is something like real-time linux, which is really a microkernel running an instance of linux as a personality. Just like L4Linux. If you're going to run a microkernel, why not just program against a native API to take advantage of the flexibility and performance?

      If microkernel designs are so great, then people will naturally start using those new microkernel facilities to add new drivers, file systems, etc.

      I guess we'll see.

    23. Re:agreed 100% by naasking · · Score: 1

      Instead of arguing ideology and theory, why don't you do some research and read some papers to back up your claims: Java Operating Systems: Design and Implementation.

    24. Re:agreed 100% by Eli+Gottlieb · · Score: 1

      As a little more addendum, I'll just submit that Pascal/Object Pascal is perfectly usable for writing kernels (including microkernels) and that if you want proof you are free to check out the kernel I'm writing.

    25. Re:agreed 100% by Anonymous Coward · · Score: 0

      Wake me up when normal hardware executes java bytecode or any other non assembly languaje. :)
      Meanwhile my point remains, all your 'better than C' languajes and logical constructions (goto's are bad, oo, exceptions, etc ) are executed as simple assembler sequences full of test/jumps, because that's what the cpu is designed to do, nothing more.
      C is just a magnific macro assembler generalization, that's why it's still widely used on low level (ok and not so low level) software.

    26. Re:agreed 100% by naasking · · Score: 1

      To be honest, I'm not sure I see the point in writing a microkernel in a high-level language. By definition, microkernels comprise the bare minimum of functionality required to expose a portable API. That means there will be very little if any code reuse, and all algorithms will be very low-level. The only benefits of languages at a higher level than C are type strictness and a bit more safety. At the moment, Ada fits that bill best as far as I can see. BitC will be much better.

      Good luck with your project. :-)

    27. Re:agreed 100% by idlake · · Score: 1

      All early operating systems were written in low-level languages, essentially assembler.

      Come on, "early" is an irrelevant qualifier. The fact remains that languages like Modula-2, Modula-3, PL/1, Ada, Oberon, Lisp, Smalltalk, Cedar/Mesa, and Object Pascal have all been used for implementing operating systems, many of the commercial and widely used. The use of C for implementing operating systems is a fairly recent and mostly academic phenomenon.

      You mean Lisp machines? That requires special hardware. [...] C is barely a step up above assembler. You can't get higher performance than assembler. [...] Perhaps you should re-read my post. From application-level programming perspectives, these features are well-motivated. From a microkernel perspective these features are ill-motivated, if feasible at all.

      That's just the usual kinds of unfounded prejudices and misconceptions C fanboys have against all other languages and systems. It's really pointless to try to argue against them--there is a certain degree of stubbornness one simply can't overcome.

      Well, it's pretty clear we aren't going to convince each other. For my work, I need a kernel into which I can hack new security and networking facilities. Sadly, the only realistic choices are C-based at this point. But between the available choices, the monolithic kernels look more attractive than the microkernels in every respect.

      In the end, people like you will have to convince people like me that kernels like Mach and CapROS are worth the hassle, and you consistently fail to do that, in papers as well as discussions. It's really not surprising that new operating system approaches have made so little headway over the last several decades.

    28. Re:agreed 100% by idlake · · Score: 1

      I know that work. It's an article talking about retrofitting a process model into a JVM. I don't think that's the right approach right now for many reasons.

      I think the right choice for an OS kernel at this point is something very similar to the Linux kernel, with separate user-mode processes. It's just that the OS kernel itself should be implemented in something a little higher level and a little safer than C, with the ability to drop down into unsafe operations when necessary and with some simple object oriented facilities. Oberon seems like roughly the right level, or maybe a Java implementation like gcj.

      But tell you what: why don't you do some research about languages and OS implementations. Go look at languages like PL/1, Oberon, Algol, Modula-2, Modula-3, Ada, and Cedar/Mesa. Go look at operating systems like Alto, Multics, Oberon, Apple Lisa, and B5000.

      Also, go look up the discussions on aliasing and pointers in C and all the problems that caused with optimization over the evolution of C since K&R. C is not, and has never been, a high performance language and often does not come even close to carefully written assembly language or well-optimized code for other languages. The other big problem with C is that many of its low-level features unnecessarily rely on implementation-specific features that aren't part of the standard. C was a charming language 20 years ago because it fit onto a PDP-11 and on a CP/M machine where nothing else would fit; but that appeal really doesn't hold anymore.

    29. Re:agreed 100% by naasking · · Score: 1
      Come on, "early" is an irrelevant qualifier. The fact remains that languages like Modula-2, Modula-3, PL/1, Ada, Oberon, Lisp, Smalltalk, Cedar/Mesa, and Object Pascal have all been used for implementing operating systems, many of the commercial and widely used. The use of C for implementing operating systems is a fairly recent and mostly academic phenomenon.

      Well, I've asked you repeatedly to point me to some evidence backing up your assertions. I've stated quite clearly that the above languages (save Ada and possibly Pascal) are unsuitable for microkernel implementations. I have yet to encounter a modern operating system, in other words, one with features post 1970s, that was written in the above languages. In case you didn't know, evidence trumps assertions.

      So please, enlighten me. Here are the requirements for the language:
      1. low-level control over representation/memory layout (hardware interfacing demands this)
      2. control over runtime environment (you can't enforce a runtime environment on some kernel designs)
      3. readily available compiler (preferably free as in beer, at the very least, since academic and free software work is, well, free)

      The only candidates that fit that bill are, you guessed it:
      1. C
      2. C++
      3. Ada
      4. Pascal

      Most programmers stay away from Pascal due to quirks which they can't stand. Ada also inherited a few of these quirks, but is a marked improvement.

      And just for curiosity's sake, show me a kernel and/or operating system that doesn't depend upon special hardware written in:
      1. Smalltalk (which came long after C FYI)
      2. Modula-* (also came long after C)
      3. Mesa/Cedar
      4. Lisp

      And FYI, I never stated C is the ultimate low-level language; it became widespread because of the spread of UNIX, and the ready availability of the C compiler on that platform. The momentum was furthered by the spread of free C compilers and the marked lack of alternative language implementations.

      Also, it's strange that you should think developing in C is an academic phenomenon when it's clear from the literature that computer researchers try as far as possible to avoid C in favour of higher-level languages.

      That's just the usual kinds of unfounded prejudices and misconceptions C fanboys have against all other languages and systems. It's really pointless to try to argue against them--there is a certain degree of stubbornness one simply can't overcome.

      So I'm a C fanboy now? Actually, I detest C, but I do recognize the right tool for the job.

      Well, it's pretty clear we aren't going to convince each other. For my work, I need a kernel into which I can hack new security and networking facilities. Sadly, the only realistic choices are C-based at this point. But between the available choices, the monolithic kernels look more attractive than the microkernels in every respect.

      Well, good luck with that. Let us all know how you manage to implement security policies in a design that is completely incapable of enforcing them.

      In the end, people like you will have to convince people like me that kernels like Mach and CapROS are worth the hassle, and you consistently fail to do that, in papers as well as discussions.

      You know, you have yet to level a single point against any operating system that I support; you've mostly been ranting against the use of low-level languages in OS research. I'm not sure precisely how that translates into a conclusion that microkernels, and that CapROS in particular, aren't worthwhile. Really, you're only valid reason is that Linux is more developed (which is a valid reason). Without evidence to the contrary, which I have provided and you haven't, any conclusions otherwise are simply unfounded.

      It's really not surprising that new operating system approaches have made so little headway over the last several decades.

      It really is a shame that people get so stuck in their mindsets and are so convinced they're right that they fail to acknowledge evidence to the contrary, isn't it?
    30. Re:agreed 100% by naasking · · Score: 1

      It's just that the OS kernel itself should be implemented in something a little higher level and a little safer than C, with the ability to drop down into unsafe operations when necessary and with some simple object oriented facilities.

      No argument there (except object-oriented facilities which have little use in microkernels). Hence the reason for developing BitC and Coyotos.

      Oberon seems like roughly the right level, or maybe a Java implementation like gcj.

      I've love to see you fit garbage collection into a kernel environment. GC has made leaps and bounds in the past 20 years, but it's still infeasible for a high-performance operating system kernel (without hardware support that is). It's almost there though. Maybe another 10 years.

      But tell you what: why don't you do some research about languages and OS implementations. Go look at languages like PL/1, Oberon, Algol, Modula-2, Modula-3, Ada, and Cedar/Mesa. Go look at operating systems like Alto, Multics, Oberon, Apple Lisa, and B5000.

      Why don't you show me an operating system that actually has some modern features and we'll talk. Oberon is as close you can get, and it's unusable because it forces you to use Oberon exclusively.

      Also, go look up the discussions on aliasing and pointers in C and all the problems that caused with optimization over the evolution of C since K&R. C is not, and has never been, a high performance language and often does not come even close to carefully written assembly language or well-optimized code for other languages.

      Every programming language performance comparison in existence, with the exception of Fortran and assembly, says otherwise. But hey, who cares about evidence when you have an ideology?

      And I'm well aware of the optimization limitations caused by aliasing. The fact is however, you will not find a language that meets the criteria I laid out in my other post, with the minimalism of C.

      The other big problem with C is that many of its low-level features unnecessarily rely on implementation-specific features that aren't part of the standard.

      Very few such features exist, they are well known, and they aren't used in operating system kernels. You are really grasping at straws here.

    31. Re:agreed 100% by be-fan · · Score: 1

      Eh, what? Define "proof-carrying code". Most Lisp compilers will (unless they are told not to) generate safe code. Both existing Dylan compilers will also. I'm sure the Haskell and ML compilers do as well. Would signing one of the resulting binaries count as "proof-carrying code"?

      --
      A deep unwavering belief is a sure sign you're missing something...
    32. Re:agreed 100% by be-fan · · Score: 1

      Without proof-carrying code or hardware support, ensuring memory protection at any granularity without implementing a full-blown virtual machine is impossible.

      I don't see how this reply answers my question. You claimed that technology needs to be developed to allow depending on language-level safety on existing machines. I said the technology is already there, all that is required is some mechanism for allowing the system to verify that a program was compiled on a trusted compiler. Heck, you could even likely use DRM for such purposes.

      --
      A deep unwavering belief is a sure sign you're missing something...
    33. Re:agreed 100% by be-fan · · Score: 1

      Can you honestly tell me with a straight face that JITC techniques, garbage collection, and other high-level features are competitive with C for producing such code?

      I'm not well-versed on JIts, but garbage collectors generally have better cache behavior than most manual memory managers. Compacting GC's tend to increase cache locality by compating live data together.

      --
      A deep unwavering belief is a sure sign you're missing something...
    34. Re:agreed 100% by be-fan · · Score: 1

      C is barely a step up above assembler.

      On a RISC machine, C is a huge step up from assembler. The C "machine model" is designed around a non-pipelined CPU that handles one instruction at a time, and has a uniform memory. Modern CPUs look nothing like that. They usually have several relatively deep pipelines, and a memory hierarchy with access costs that differ by orders of magnitude. In assembler, you can precisely tune the code scheduling to take advantage of that architecture. In C, you have to trust the compiler to do it. Good C compilers usually can, but then again, so can good ML compilers. However, the fact that the compiler can transform the program into something close to machine code doesn't change the fact that C programs, to begin with, are quite far away from machine code.

      --
      A deep unwavering belief is a sure sign you're missing something...
    35. Re:agreed 100% by naasking · · Score: 1

      I'm not well-versed on JIts, but garbage collectors generally have better cache behavior than most manual memory managers. Compacting GC's tend to increase cache locality by compating live data together.

      GC is non-predictable, so it's already out the window for any systems that hope to schedule anything close to realtime. Even "realtime garbage collection algorithms" don't yet have the numbers to justify their use in critical kernel paths. I've read that their mutator overheads are still above 50%, which is unacceptable in this domain.

      Furthmore, many, if not most, modern microkernel designs have a "no kernel state" model, which means GC is pointless anyway as the kernel never frees memory. It allocates the only structures it will ever need at boot time, and those structures remain live until system shutdown. Avoiding state means that the kernel is not vulnerable to denial-of-resource attacks.

      My argument in the parent post was questioning the grandparent's assertion that code-generation and other high-level techniques belong in the kernel, particularly a microkernel where the critical paths are often finely hand-tuned for performance. It's doubtful that a code-generator could do better, and these high-level features aren't even needed in a kernel since they introduce additional vulnerabilities to the system (like DOS for code-generation -- see Pebble OS for example). I don't doubt they're possible, and I don't doubt they could bring certain advantages, but just because we can, doesn't mean we should; there are many security (much larger TCB) and reliability (much more verification) concerns.

    36. Re:agreed 100% by naasking · · Score: 1

      I don't see how this reply answers my question. You claimed that technology needs to be developed to allow depending on language-level safety on existing machines.

      No, this thread is about using these language implementations in a kernel. Some other thread offshoots also discuss using the entire language runtime as the basis for whole operating system runtime safety.

      Language-level safety of the latter sort is a dead-end; you will never be able to sell to any appreciably sized market, a system that depends on a single language to run everything.

      Also, "proof-carrying code" is a much stricter definition than what you seem to imply (google for it).

      And notice, I never said we didn't have the technology, I said we don't have the implementations. Ada is proof enough that we can do better than C in terms of safety (although it too has a host of problems). Cyclone with region memory management is potentially even better than Ada in constrained environments. The technology, the knowledge exists, it just hasn't been brought together in a sufficiently low-language with which we can build microkernels. That's the drive behind BitC.

    37. Re:agreed 100% by naasking · · Score: 1

      Define "proof-carrying code".

      Proof Carrying Code.

      Most Lisp compilers will (unless they are told not to) generate safe code.

      We're not just talking about memory or type safety. If that was all that was needed, I'd just recommend Ada.

    38. Re:agreed 100% by naasking · · Score: 1

      However, the fact that the compiler can transform the program into something close to machine code doesn't change the fact that C programs, to begin with, are quite far away from machine code.

      This also doesn't change the fact that C memory layouts translate directly byte-for-byte from source, to in-memory representation. All other higher-level languages discussed thus far explicitly allow the compilers to reorder fields as they see fit. This is unaccetable for code that interfaces with hardware. Thus, kernels must still be written in low-level languages that allow explicit control over representation.

      I'm all for type safety, memory safety, and all sorts of other high-level goodies, but until the three criteria are met by another candidate, C remains the choice to beat.

    39. Re:agreed 100% by be-fan · · Score: 1

      Memory and type safety is all you need to be able to dispense with the hardware level protections on existing CPUs. Proof carrying code might get you better protection guarantees, but it's not necessary to offer the level of protection offered by existing MMUs.

      --
      A deep unwavering belief is a sure sign you're missing something...
    40. Re:agreed 100% by be-fan · · Score: 1

      Language-level safety of the latter sort is a dead-end; you will never be able to sell to any appreciably sized market, a system that depends on a single language to run everything.

      *Cough* .NET *Cough*. Seriously, there is no reason the language in question must be a high-level language usable for programmers. The language could be something like the .NET IL, which other languages could target.

      Cyclone with region memory management is potentially even better than Ada in constrained environments.

      Region memory management has *very* real problems in constrained environments. It is lower overhead than GC in CPU time, but must necessarily keep garbage around a lot longer.

      The technology, the knowledge exists, it just hasn't been brought together in a sufficiently low-language with which we can build microkernels. That's the drive behind BitC.

      Any decent Lisp compiler has low-level instructions (which could be blocked for user-level programs). You'd need some ASM for things like writing to I/O ports and special registers, but you need that for C as well.

      --
      A deep unwavering belief is a sure sign you're missing something...
    41. Re:agreed 100% by be-fan · · Score: 1

      GC is non-predictable, so it's already out the window for any systems that hope to schedule anything close to realtime.

      Most memory management algorithms are non-predictable. Nobody who writes real-time code believes that malloc() is suitable for real-time use. In "real" real-time code, you use the idiom of pre-allocating everything you need before you hit the critical path. This idiom holds for both GC'ed languages (in which you turn off the GC in the critical path), and manually-managed languages. Beyond that, define "close to real time"? Are Linux, Windows, et-al, close enough for you? The MPS has maximum pause times of around 50ms on my 3-year-old P4 2.0GHz. I can get pause times higher just by accidentally referencing a page that the VM has swapped out. The simple truth is that most people don't need hard real-time. Soft real-time is good enough, and on modern CPUs, GC can do that.

      Even "realtime garbage collection algorithms" don't yet have the numbers to justify their use in critical kernel paths. I've read that their mutator overheads are still above 50%, which is unacceptable in this domain.

      It's a very contrived scenario in which hard-real time guarantees are required, the mutator is highly CPU intensive, and the required performance cannot be achieved by simply doubling CPU capacity. To be honest, I can't think of any such scenarios!

      --
      A deep unwavering belief is a sure sign you're missing something...
    42. Re:agreed 100% by be-fan · · Score: 1

      This also doesn't change the fact that C memory layouts translate directly byte-for-byte from source, to in-memory representation.

      Which is not true on any modern C implementation. You can't depend on code layout at all, stack layout varies between compilers (and optimization settings), as does struct layout. No careful programmer does something like write() directly from a struct, and expect it to behave properly in any reasonable fashion.

      Thus, kernels must still be written in low-level languages that allow explicit control over representation.

      Bollocks. Kernels just need to be written in languages that allow direct control over in-memory representation for code that needs it. Any high-level language that offers functions for operating on machine-words fits the bill. This is true of all modern Lisps, which need such capabilities for accessing C libraries.

      --
      A deep unwavering belief is a sure sign you're missing something...
    43. Re:agreed 100% by Anonymous Coward · · Score: 0

      At some point you have to write a memory manager.
      At some point you have to write a cpu scheduler.
      At some point you have to write a time interrupt handler. ...


      Dude, IBM wrote a complete Java virtual machine in Java, except for like 1k of assembly code. It even gets good performance. WTF makes you think Java w/ a few assembly routines can't do any of that?

      Try searching google for "JavaOS" and "jxos" and read.

    44. Re:agreed 100% by Anonymous Coward · · Score: 0

      Every programming language performance comparison in existence, with the exception of Fortran and assembly, says otherwise.

      Bull. C *only* wins those because of its reckless abandon. You add types to LISP and turn off the checking and it's faster than C. Java is 50% slower at benchmarks primarily reading/writing to an array? Now turn off bounds checks in Java and it's the same speed or faster.

      In a safe OS, system.getPID() takes *one instruction*. In an unsafe one it takes 1200+ cycles.

      In a safe OS, new() takes 10 instructions, slightly more if it needs to switch to a new generation area (GC mostly takes place during otherwise idle time). In an unsafe one it takes 50-80... sometimes it takes 2000+ cycles (~1200 to switch into the kernel for mmap, lots of other instructions to map in a new page).

      In a safe OS, read() does one DMA copy into memory. In an unsafe OS read does that plus at least one other copy (then you call write and make another copy...), or kernel remaps pages in memory which is a bit faster but still much slower than just using the memory.

      In a safe OS, an application can use all the available memory space. In an unsafe OS, applications are limited as the space is split between app and kernel... either that or the transitions and copying between app and kernel are even slower.

      Those benchmarks are of C on an unsafe kernel versus Java on an unsafe kernel. Try flipping it and running C on a safe kernel and Java on a safe kernel and Java will win by much higher spread.

      The majority of the CPU time on a desktop is unused, and when used it's in short bursts; this is perfect for a safe language where it can litter up the memory during a burst and compact/clean it during an idle period. The majority of the time on a server is kernel-and-app transitions, which is why they put web servers like tux into the kernel. Either case has benefits for a safe kernel that likely outweigh the minor costs in micro-benchmark performance.

    45. Re:agreed 100% by Anonymous Coward · · Score: 0

      Fantastic OS, and the java part runs on top of a ... C/asm microkernel. Exactly what the parent poster said.

    46. Re:agreed 100% by idlake · · Score: 1

      1. low-level control over representation/memory layout (hardware interfacing demands this)

      C does not have sufficient low-level control over representation/memory layout for hardware interfacing; any such "control" you get is highly implementation dependent, and the same kernel code compiled with different C compilers will often not work. Furthermore, there are no defined semantics for the code the compiler generates for accessing data structures, which can cause problems with memory mapped I/O.

      2. control over runtime environment (you can't enforce a runtime environment on some kernel designs)

      You have no more and no less control over the runtime environment in C than you do in any other language. A conforming C compiler and runtime is perfectly free to use garbage collection and to terminate your program the first time you use "float x; return *(char*)".

      When C is used for implementing kernels, people generally take the C compiler and implement their own C runtime for the kernel. That's exactly what you do when you use any other language, including languages with garbage collection, for implementing kernels.

      3. readily available compiler (preferably free as in beer, at the very least, since academic and free software work is, well, free)

      Building a small compiler to support kernel development is negligible amounts of work compared to implementing the kernel, and there are plenty of compilers you could build on (Eiffel, Portable Object Compiler, tcc, Oberon, etc.).

      The only candidates that fit that bill are, you guessed it: C, C++, Ada, Pascal

      C and C++ do not fit your requirements at all; you only think they do because you confuse implementation-specific features that are not part of the language with the language itself. At best, you can argue that the specific language implemented by gcc with an Intel backend is good for your purposes, but the C programming language is, by itself, completely unsuitable for implementing kernels.

      I'm not sure precisely how that translates into a conclusion that microkernels, and that CapROS in particular, aren't worthwhile.

      Here, I have criticized EROS (and by extension CapROS) for its microkernel design--relying on memory management hardware rather than language and runtime mechanisms in order to achieve correctness. Apparently, the EROS authors themselves realized this, which is why Coyotos uses a new programming language.

      I haven't said anything beyond that about EROS; that would be an entirely separate discussion. The fundamental problem I see with the EROS approach is that it is principle driven, rather than data driven. These people keep talking about "trust" and "security" without ever demonstrating measurable improvements in those areas under controlled conditions.

      It really is a shame that people get so stuck in their mindsets and are so convinced they're right that they fail to acknowledge evidence to the contrary, isn't it?

      Well, you should know.

    47. Re:agreed 100% by idlake · · Score: 1
      I should proofread... that should have been:

      to terminate your program the first time you use "float x; return *(char*)&x;".


      and it should have been:

      relying on memory management hardware rather than language and runtime mechanisms in order to achieve isolation.
    48. Re:agreed 100% by idlake · · Score: 1

      "The other big problem with C is that many of its low-level features unnecessarily rely on implementation-specific features that aren't part of the standard." Very few such features exist, they are well known, and they aren't used in operating system kernels. You are really grasping at straws here.

      No, you simply do not understand C at all. Structure layout, memory access through cast pointers, memory allocation and management, and memory mapped I/O are all highly implementation dependent features.

      Hence the reason for developing BitC and Coyotos.

      Which only goes to show that all your objections to how one can't use anything other than C are groundless.

      We could now start debating whether the methodology underlying the development of EROS and Coyotos ("principle based") is acceptable and whether the authors are actually properly testing their claims or just handwaving. We could also discuss whether even the principles that the authors of those systems pursue hold water or are misguided. But those are separate discussions.

    49. Re:agreed 100% by naasking · · Score: 1

      No, because then you are enforcing a particular language or runtime on an entire operating environment. This never has and never will work. To be useful a system must support arbitrary computational semantics. To be secure in such an environment it must support mutually suspicious co-operation.

    50. Re:agreed 100% by naasking · · Score: 1

      *Cough* .NET *Cough*. Seriously, there is no reason the language in question must be a high-level language usable for programmers. The language could be something like the .NET IL, which other languages could target.

      You'd seriously recommend building an entire operating system, kernel included, on a single IL?

      Region memory management has *very* real problems in constrained environments. It is lower overhead than GC in CPU time, but must necessarily keep garbage around a lot longer.

      Depends on how you use it, certainly. The CPU time isn't what concerns me, the fact that it's explicit and predictable is what matters here.

      Any decent Lisp compiler has low-level instructions (which could be blocked for user-level programs). You'd need some ASM for things like writing to I/O ports and special registers, but you need that for C as well.

      Certainly. That's not the problem though; BitC itself has a Lisp/Scheme syntax, so it's not a limitation of the language, but the operational semantics. Lisp requires GC. Lisp cannot grant you sufficient control of the runtime. Thus, Lisp is unsuitable. If you modify Lisp to support these features, great, but then you no longer have Lisp, just something Lisp-like.

    51. Re:agreed 100% by naasking · · Score: 1

      In "real" real-time code, you use the idiom of pre-allocating everything you need before you hit the critical path. This idiom holds for both GC'ed languages (in which you turn off the GC in the critical path), and manually-managed languages.

      Right, so you move from doing manual memory management, to doing manual GC management. How is this a big win exactly?

      Soft real-time is good enough, and on modern CPUs, GC can do that.

      Says who? It's not good enough for people who want to ensure their system can be used for hard realtime.

    52. Re:agreed 100% by naasking · · Score: 1

      Which is not true on any modern C implementation. You can't depend on code layout at all, stack layout varies between compilers (and optimization settings), as does struct layout.

      ANSI C strictly forbids field reordering.

      No careful programmer does something like write() directly from a struct, and expect it to behave properly in any reasonable fashion.

      You certainly can, but it's stupid because a) it's brittle and can break with future changes to the struct, and b) it's pottentially nonportable across architectures with endianness differences.

      Kernels just need to be written in languages that allow direct control over in-memory representation for code that needs it.

      By definition, a microkernel is composed almost exclusively by such code. Where is the advantage of using a higher-level language then?

    53. Re:agreed 100% by naasking · · Score: 1

      Structure layout

      ANSI C strictly forbids field reordering. In-memory layout is precisely as defined in the struct to the nearest byte (bit fields are known to be non-portable and thus unusable).

      memory access through cast pointers

      Defined by the host architecture. I'm not sure what C has to do with this. It merely defines a portable syntax for pointer dereference.

      memory allocation and management

      Portable malloc/free API. Not sure what you're point is here.

      memory mapped I/O

      Not part of the C standard.

      Which only goes to show that all your objections to how one can't use anything other than C are groundless.

      I never said you can't use anything other than C. Are you even reading what I write? I merely said that C is the currently probably the best candidate, particularly for a microkernel implementation.

      We could now start debating whether the methodology underlying the development of EROS and Coyotos ("principle based") is acceptable and whether the authors are actually properly testing their claims or just handwaving. We could also discuss whether even the principles that the authors of those systems pursue hold water or are misguided. But those are separate discussions

      What claims? Security claims? Performance claims?

    54. Re:agreed 100% by naasking · · Score: 1
      C does not have sufficient low-level control over representation/memory layout for hardware interfacing; any such "control" you get is highly implementation dependent, and the same kernel code compiled with different C compilers will often not work.

      My other post addressed this. ANSI C forbids field reordering.

      You have no more and no less control over the runtime environment in C than you do in any other language. A conforming C compiler and runtime is perfectly free to use garbage collection and to terminate your program the first time you use "float x; return *(char*)".

      No, C explicitly allows one to have no runtime, which is critical for some applications; this is the point I've been repeating over and over, and yet you don't seem to comprehend. You can't achieve this in other languages at the moment (except as I pointed out, C++, Ada), unless you roll your own.

      Building a small compiler to support kernel development is negligible amounts of work compared to implementing the kernel, and there are plenty of compilers you could build on (Eiffel, Portable Object Compiler, tcc, Oberon, etc.).

      So, where's yours then? You do kernel level work with "security and networking" features, so I'm sure it would benefit you to have all of your code verified correct. The truth is a portable language definition and implementation for any architecture is hard. C is already well-defined for low-level work, ubiquitous, and "good-enough" for most kernel-projects (except those seeking verification).

      C and C++ do not fit your requirements at all; you only think they do because you confuse implementation-specific features that are not part of the language with the language itself. At best, you can argue that the specific language implemented by gcc with an Intel backend is good for your purposes, but the C programming language is, by itself, completely unsuitable for implementing kernels.

      All the features of "C" you've pointed out have turned out to be either not features of the C standard at all, or completely incorrect. I'm not sure you're qualified to make such declarations. If you are, let's see some real evidence. Point me to the C standard features that preclude it's use for kernel development.

      Here, I have criticized EROS (and by extension CapROS) for its microkernel design--relying on memory management hardware rather than language and runtime mechanisms in order to achieve correctness. Apparently, the EROS authors themselves realized this, which is why Coyotos uses a new programming language.

      This is completely incorrect. You are conflating safety, correctness and security. Capabilities and correct use of MMU provide safety, and security guarantees (among mutually suspicious parties -- the point of EROS/CapROS). BitC will additionally provide correctness guarantees (the point of Coyotos).

      I haven't said anything beyond that about EROS; that would be an entirely separate discussion. The fundamental problem I see with the EROS approach is that it is principle driven, rather than data driven. These people keep talking about "trust" and "security" without ever demonstrating measurable improvements in those areas under controlled conditions.

      I seriously think you don't understand the capability security model. Let me help:
      1. Capability Myths Demolished
      2. Darpa security review of CapDesk
      3. SCOLL: A Language for Safe, Capability-based Collaboration
      4. SCOLL and SCOLLAR : Safe Collaboration based on Partial Trust
    55. Re:agreed 100% by naasking · · Score: 1

      relying on memory management hardware rather than language and runtime mechanisms in order to achieve isolation.

      MMU hardware is a runtime mechanism. It's just a mechanism implemented in circuitry rather than software.

      Perhaps you could clarify exactly what runtime mechanisms you have in mind that could supplant MMU hardware for safety and fault isolation guarantees? You outlined your belief that the kernel should be implemented in a safe language. Very good. I suspect this kernel will still run at supervisor level on the CPU. How about objects hosted on this kernel? Would they run at user or supervisor level? Is the kernel a JITC VM? How are entities scheduled? How are resources, memory for instance, tracked and charged to various entities? How do you ensure freedom from denial-of-service attacks against the kernel, realtime scheduling, etc.? These are all issues handled by operating systems at the moment, so I'd like to hear your solutions for these problems, even speculative ones.

    56. Re:agreed 100% by idlake · · Score: 1

      ANSI C strictly forbids field reordering. In-memory layout is precisely as defined in the struct to the nearest byte (bit fields are known to be non-portable and thus unusable).

      ANSI C forbids reordering, but it doesn't define the size of a byte, nor does it precisely define alignment or padding.

      Portable malloc/free API. Not sure what you're point is here.

      The point is that the kernel doesn't use the language-supplied malloc/free; it uses its own unportable mechanisms.

      "memory mapped I/O" Not part of the C standard.

      My point exactly.

      I merely said that C is the currently probably the best candidate, particularly for a microkernel implementation.

      Well, and as we can see, you don't even know what features are part of the C language. C implementations can be garbage collected and abort on every one of those "low-level features" you so dearly love as a runtime error. The C language is not so much characterized by the presence of low level features, but by the absence of guarantees that high level features are present.

      But even if you are trying to argue that using GNU C or a similar compiler on Intel is "the best candidate", that is also methodologically wrong: you claim that systems like EROS and CapROS are aimed at performance and security. But if you base those systems based on a language with no language mechanisms for fault isolation and a propensity for serious security problems, then EROS and CapROS can be argued to be merely workarounds for the limitations of their implementation language.

    57. Re:agreed 100% by idlake · · Score: 1

      I think I have stated this pretty clearly already: I'm looking for a kernel very much like the Linux or BSD kernel, but replacing C with a simple, safe object-oriented language that supports garbage collection. It would be nice if the runtime contained a JIT compiler, but that would not be necessary. Either way, modules would be dynamically loadable, communication between kernel components would happen through the language's object oriented mechanisms, and the language and runtime would guarantee fault isolation and resource reclamation (except in contexts where the programmer explicitly overrides it).

      That's in contrast to microkernels that take the functionality currently contained in kernels like Linux or BSD and split it up among separate processes; the microkernel approach introduces unnecessary overhead and complications into the kernel design. I view microkernels as a workaround for the lack of runtime safety in languages like C.

      It's also in contrast to the Lisp machine or some attempts at a Java OS, in which everything, including applications, runs inside a single big runtime and address space; resource management and other issues haven't been solved satisfactorily in that context and current applications aren't written for that kind of environment. However, once you have moved to a safe language and runtime, you can start exploring the issue of moving more functionality into the kernel's address space.

    58. Re:agreed 100% by be-fan · · Score: 1

      You'd seriously recommend building an entire operating system, kernel included, on a single IL?

      To quibble: there is no reason to use a single IL. It just needs a trusted compiler for each IL it does support. Furthermore, what exactly do you think C is anyway? It's essentially the common IL for UNIX. The C machine model is deeply ingrained within UNIX, just as much as the CIL machine model is ingrained within the .NET CLR. Even if you do use a single IL, which you don't have to, it's really no different from existing systems.

      Depends on how you use it, certainly. The CPU time isn't what concerns me, the fact that it's explicit and predictable is what matters here.

      If I understand the term the same way, you're talking about something like what is used in the MLton compiler, which automatically inferences regions and allocates to them. Such region management is not any more explicit or predictable than GC or regular malloc() for that matter. I suppose you can include annotations in the program to delineate regions, but then why not just use the "preallocate and disable collection" idiom in a regular GC?

      Certainly. That's not the problem though; BitC itself has a Lisp/Scheme syntax, so it's not a limitation of the language, but the operational semantics. Lisp requires GC. Lisp cannot grant you sufficient control of the runtime. Thus, Lisp is unsuitable. If you modify Lisp to support these features, great, but then you no longer have Lisp, just something Lisp-like.

      What exactly do you think the Linux kernel is written in? In C? If I recall correctly, there is no inline asm in C99. Rather, Linux is written in a C-like language. You generally cannot write an OS kernel in C, because there is no way to emit traps, handle interrupts, etc, from C. You need to extend the language with an asm library (or inline asm), which is exactly what Lisps do. So sure, you can call them "Lisp-like" languages instead, but be aware that if you don't start applying the same reasoning to C, you're being inconsistent.

      --
      A deep unwavering belief is a sure sign you're missing something...
    59. Re:agreed 100% by be-fan · · Score: 1

      Right, so you move from doing manual memory management, to doing manual GC management. How is this a big win exactly?

      Because memory protection is still enforced.

      Says who? It's not good enough for people who want to ensure their system can be used for hard realtime.

      Says everybody who is perfectly happy using Linux, Windows, BSD, OS X, etc, even with their unpredictable latencies of hundreds of milliseconds. Most kernels are not hard real-time. Those that are can be written in an approprite hard-real time language (either a safe one with a RTGC, or C with no MMU, no VM, and a RT malloc).

      --
      A deep unwavering belief is a sure sign you're missing something...
    60. Re:agreed 100% by be-fan · · Score: 1

      ANSI C strictly forbids field reordering.

      It does not forbid variations in field padding, however. The rules for how fields are padded are predictable, but that does not change the fact that they are not "byte for byte" translations.

      You certainly can, but it's stupid because a) it's brittle and can break with future changes to the struct, and b) it's pottentially nonportable across architectures with endianness differences.

      And c), it's non-portable because ANSI says nothing about the precise size of types or their alignment (and hence the internal padding of the struct).

      By definition, a microkernel is composed almost exclusively by such code. Where is the advantage of using a higher-level language then?

      Hardly. Even microkernels are full of logic (validating user input, for example). Even if you say a microkernel spends 50% of its code banging registers and memory locations (likely a gross overestimation), that's still 50% you don't have to write in a low-level language.

      --
      A deep unwavering belief is a sure sign you're missing something...
    61. Re:agreed 100% by naasking · · Score: 1

      ANSI C forbids reordering, but it doesn't define the size of a byte, nor does it precisely define alignment or padding.

      Re: size of byte

      Did you forget that not all architectures are byte-machines?

      Re: alignment

      That's what pointer arithmetic is for, which is needed for memory management anyway.

      Re: padding

      Padding is a trivial issue in C.

      No doubt the above are useful features to handle uniformally in the compiler (and Ada addresses all of them better than C), but they are not show-stoppers.

      The point is that the kernel doesn't use the language-supplied malloc/free; it uses its own unportable mechanisms.

      It can. It doesn't have to be unportable. The only unportable code is allocating and freeing pages. This is architecture-specific code anyway.

      My point exactly. (Re: memory-mapped I/O)

      Because memory mapped I/O is not a feature of every OS in existence. The C library is pretty much designed for the lowest common denominator; this is a strength when dealing with kernels and the fact that these features are not required is its greatest strength for microkernels. I really don't see how memory-mapped I/O belongs in a microkernel anyway. You are arguing the lack of application-level features as a criticism for using a language in a kernel.

      Well, and as we can see, you don't even know what features are part of the C language.

      I'm not sure how you reached that conclusion. Where is your evidence to back up this assertion?

      C implementations can be garbage collected and abort on every one of those "low-level features" you so dearly love as a runtime error

      I never made any claims that C was a great language, nor that it was particularly safe, nor that garbage collection is even a good fit for it. I'm not sure where you're getting your outlandish ideas, but from the beginning I've simply maintained that C is currently the best language in which to write a microkernel (Ada would be better, but I've encountered serious code bloat issues with it -- this kills cache performance). Any other claims you make are a strawman.

      The C language is not so much characterized by the presence of low level features, but by the absence of guarantees that high level features are present.

      To a certain extent I agree. Unfortunately, all other high-level language implementations currently force you to carry other baggage that simply doesn't belong in a microkernel; at least, not every microkernel -- the fact that it isn't even an option is the problem.

      But even if you are trying to argue that using GNU C or a similar compiler on Intel is "the best candidate", that is also methodologically wrong: you claim that systems like EROS and CapROS are aimed at performance and security. But if you base those systems based on a language with no language mechanisms for fault isolation and a propensity for serious security problems, then EROS and CapROS can be argued to be merely workarounds for the limitations of their implementation language.

      Tell me, how do you gain confidence in a compiler verification? It was clearly originally written in a language less safe than itself, so how do you know it's bug-free? How do you know the implementations of its proofs are correct? You test it till the cows come home. That's called a solid epistemology. You verify through observation.

      The longer a microkernel is tested without problems, the greater the confidence we gain in it. This confidence perhaps has an upper bound which is determined by the unsafety of the language and the complexity of the implementation. This is why microkernels seek to minimize the implementation. This is why the Coyotos implementors seek to improve the safety of the implementation.

    62. Re:agreed 100% by naasking · · Score: 1

      I think I have stated this pretty clearly already: I'm looking for a kernel very much like the Linux or BSD kernel, but replacing C with a simple, safe object-oriented language that supports garbage collection. It would be nice if the runtime contained a JIT compiler, but that would not be necessary. Either way, modules would be dynamically loadable, communication between kernel components would happen through the language's object oriented mechanisms, and the language and runtime would guarantee fault isolation and resource reclamation (except in contexts where the programmer explicitly overrides it).

      Ok, now we're getting somewhere. And here is the problem with this design: you seem to be ignoring the fact that it's running on a real machine without these high-level features. The only way to implement this system, is have the kernel as a full-blown virtual machine which only runs some sort of IL which doesn't allow arbitrary code execution/memory accesses. This means code-generation. This means garbage collection. This means forcing everyone to use the same IL. This means a new compiler for any language you want to support. This means only source-level compatibility. This makes the kernel vulnerable to denial-of-service attacks.

      There is one other possibility: some sort of code-signing scheme to ensure that the code was compiled on a certified compiler (would only work with DRM of some sort). What a terrible idea this would be...

      That's in contrast to microkernels that take the functionality currently contained in kernels like Linux or BSD and split it up among separate processes; the microkernel approach introduces unnecessary overhead and complications into the kernel design. I view microkernels as a workaround for the lack of runtime safety in languages like C.

      a) The kernel design is actually much simpler. I'm not sure what's so complex about it; it's just IPC. Please elaborate.
      b) Overhead issues have largely been addressed in the latest generation of microkernels (L4, EROS/CapROS).

      In some sense a microkernel is a workaround for safety issues: by decomposing functionality, you are isolating faults. By decomposing you are also increasing reusability of components. But it's a workaround that is necessitated by the hardware, because the hardware itself is unsafe. If we were running Lisp machines, this wouldn't even be an issue.

      It's also in contrast to the Lisp machine or some attempts at a Java OS, in which everything, including applications, runs inside a single big runtime and address space; resource management and other issues haven't been solved satisfactorily in that context and current applications aren't written for that kind of environment. However, once you have moved to a safe language and runtime, you can start exploring the issue of moving more functionality into the kernel's address space.

      So you're idea is something like J-Kernel from the paper I linked to earlier, but actually running in kernel space and executing the whole system written in Java?

    63. Re:agreed 100% by naasking · · Score: 1

      To quibble: there is no reason to use a single IL. It just needs a trusted compiler for each IL it does support.

      And what is the thing that recognizes, approves and executes each IL?

      Furthermore, what exactly do you think C is anyway? It's essentially the common IL for UNIX. The C machine model is deeply ingrained within UNIX, just as much as the CIL machine model is ingrained within the .NET CLR.

      No, no, no. The "IL" for any native code compilers are the host architecture's native instruction set.

      If I understand the term the same way, you're talking about something like what is used in the MLton compiler, which automatically inferences regions and allocates to them.

      No, Cyclone allows explicit region management IIRC. Region inference is an additional useful feature, but it's not required.

      Such region management is not any more explicit or predictable than GC or regular malloc() for that matter.

      I'm not sure if region inference is more predictable; I haven't read any papers on it. The collection cycle might be faster, and with explicit intervention, more predictable. Got any pointers?

      I suppose you can include annotations in the program to delineate regions, but then why not just use the "preallocate and disable collection" idiom in a regular GC?

      Fragmentation, no copying overhead for compaction, etc. These are important issues in constrained systems. For instance, the annotations are inline in the declaration of a pointer in Cyclone. This means it is checked by the compiler for safety. Does the compiler check that you've properly re-enabled the GC after everytime you disable it?

      What exactly do you think the Linux kernel is written in? In C? If I recall correctly, there is no inline asm in C99.

      Oh no doubt Linux uses gccisms. It's probably 80-90% C, and 5-10% asm, and 5-10% gcc extensions.

      So sure, you can call them "Lisp-like" languages instead, but be aware that if you don't start applying the same reasoning to C, you're being inconsistent.

      The main issue with Lisp is the runtime environment. Would you call Lisp without garbage collection Lisp? Have you even seen such a beast?

    64. Re:agreed 100% by naasking · · Score: 1

      Because memory protection is still enforced.

      But it's not really, since in a kernel (particularly microkernels) you have to perform pointer arithmetic. This is necessitated by the MMU. All the C code which doesn't interface with the MMU should likewise be "memory-safe" (in that there's no need to perform pointer arithmetic). So it's mostly a wash IMO. There are a few corner cases where memory safety would actually be useful, but sufficient testing would produce the same confidence in correctness. GC is a big dependency that isn't needed in microkernels, particlarly microkernels that don't have state (like EROS/CapROS). So how do you get rid of it in a language that needs it?

      Says everybody who is perfectly happy using Linux, Windows, BSD, OS X, etc, even with their unpredictable latencies of hundreds of milliseconds. Most kernels are not hard real-time. Those that are can be written in an approprite hard-real time language (either a safe one with a RTGC, or C with no MMU, no VM, and a RT malloc).

      And researchers who want to build a general-purpose operating system that can be used in all of these scenarios are what? Shit out of luck? Thanks for coming out, try being less ambitious next time?

      Listen, people can use whatever language they like to build a kernel; if it makes them happy, I'm happy for them. But to be honest, I don't see how you're going to build a microkernel with the desired properties given a high-level language and its runtime baggage. I'd like to be proven wrong. If you have seen a microkernel written in Lisp, Java, or what have you, that runs on commodity hardware, then I'd love to read about it.

    65. Re:agreed 100% by naasking · · Score: 1

      It does not forbid variations in field padding, however. The rules for how fields are padded are predictable, but that does not change the fact that they are not "byte for byte" translations.

      Right, which is why you stick to machine words.

      Hardly. Even microkernels are full of logic (validating user input, for example). Even if you say a microkernel spends 50% of its code banging registers and memory locations (likely a gross overestimation), that's still 50% you don't have to write in a low-level language.

      I think we're getting our signals crossed here. I've never stated C is ideal for writing kernels. I can honestly say I really don't like C. I would love to be able to write a kernel in a higher level language. What I am saying, is that no language is there yet; no language other than C, C++, and Ada currently provides the three features points I've outlined (low-level control, runtime control, compiler availability). C++ is possible, but you have to jump through a lot of hoops to get where you're going. Ada is great because it provides much more safety, but it has some bloating issues with the binaries it produces (gnat) which wreaks havoc on the caches critical for microkernel performance. So we're left with C, which is not as good as assembler for direct control, but it doesn't really get in our way the way the other two do for most of our purposes. It's unfortunate, but there it is.

    66. Re:agreed 100% by idlake · · Score: 1

      I'm sorry, but you still don't get my point. C is a programming language defined by a language standard. You keep claiming that C permits efficient access to low-level features, but that claim is wrong: the C programming language provides no access to low level features at all. Any such access is provided via implementation-dependent features. And just like it's easy to add those features to C, it's easy to add them to other languages.

      Similarly, the C runtime is unsuitable for use in a kernel; any kernel use of C needs its own runtime. Well, you do the same thing when writing a kernel in any other language.

    67. Re:agreed 100% by naasking · · Score: 1

      I'm sorry, but you still don't get my point. C is a programming language defined by a language standard.

      No argument there.

      You keep claiming that C permits efficient access to low-level features, but that claim is wrong: the C programming language provides no access to low level features at all.

      Fine, let's be as specific as possible. Assembly language provides direct access to low-level features. C provides direct access to datatypes which map almost directly to base valuetypes on commodity hardware. Good so far?

      Any such access is provided via implementation-dependent features. And just like it's easy to add those features to C, it's easy to add them to other languages.

      If you recall I had three criteria for a microkernel suitable language. Yes, there are other languages that provide direct control over representation (even better than C for some), or at the very least they can manipulate these representations via opaque handles and callbacks to low-level code. Ignoring the difficulties inherent in this for a moment, the other higher-level languages in this category are still unsuitable because they don't grant you sufficient control over the runtime. You can't eliminate GC from Lisp or Java for instance, without essentially writing your own implementation (which is effectively no longer Lisp or Java). Rolling your own is all well and good, but it's a lot of work.

      Similarly, the C runtime is unsuitable for use in a kernel; any kernel use of C needs its own runtime. Well, you do the same thing when writing a kernel in any other language.

      That's just it, there effectively is no "C runtime" though. There is link-time code which provide services as functions, but in C, you get what you pay for. If you don't want to pay for something (like GC), you don't have to pay for it. If you don't want dynamic memory allocation, you don't pay for it. Other language implementations as they currently exist, already assume a standard foundation (memory allocation, GC, etc.).

      C itself makes no real runtime assumptions beyond the presence of a stack. You pay for nothing else. This is essential for microkernels because there often is no memory allocation/reclamation.

    68. Re:agreed 100% by be-fan · · Score: 1

      And what is the thing that recognizes, approves and executes each IL?

      People. Using signed

      No, no, no. The "IL" for any native code compilers are the host architecture's native instruction set.

      Let's keep this discussion in context. You expressed horror at the idea of an OS that depended on a single IL. What exactly is your horror in reaction to? To answer that, we have to consider the nature of an IL. An IL exposes two things, an instruction set and a machine model. Surely, your reaction could not have been to the instruction set, as that is nearly transparent to the language-implementor. At the level of the instruction set, compiling to CIL is really no different than compiling to PowerPC or x86. It's completely transparent from the point of view of the programmer.

      What you experessed horror to, whether you realize it or not, is the idea that the OS imposes a particular machine model on the program. The machine model is something that is not transparent to the language implementor or the programmer. If the IL doesn't expose arbitrary pointer arithmetic, you'll have a check of a time implementing or using a language that features pointers. Now, to finally get back to my point: while it is regrettable that the OS must impose a particular machine model, it is almost inevitable, and indeed, UNIX imposes a very specific (and often burdensome) one. UNIX is deeply intertwined with the C machine model (serially-executing, interruptable processes accessing uniform, unprotected, untyped, and contiguous memory). Of course, the machine looks nothing like that underneath. Significant layers of hardware and software are involved in making a modern superscaler multicore NUMA machine look like a PDP-11. Nonetheless, from the point of view of language implementors and programmers, that's exactly what a UNIX machine looks like.

      An OS based on a safe IL will not be any less (or more) guilty of imposing a particular machine model: it will simply expose one that looks different. Implementors of unsafe languages will have to go through contortions to target such a machine, but that's really no different than what implementors of safe languages have to go through to target a UNIX machine!

      Oh no doubt Linux uses gccisms. It's probably 80-90% C, and 5-10% asm, and 5-10% gcc extensions.

      80-90% C is not C, it's "C-like". I personally thing its a stupid distinction, but you're the one attempting to make it (for Lisp). I'm just pointing out that, in that case, you should make it for C too.

      The main issue with Lisp is the runtime environment. Would you call Lisp without garbage collection Lisp?

      Without a GC? Likely not, but then again, we're not talking about removing the GC. That is not necessary to make a language suitable for writing kernels. We're talking about adding functionality to allow the specification of in-memory representation ("read-mem", "write-mem", "read-io-port", "write-io-port"). If C with an external function "read-io-port()" is still C, I don't see why the same isn't true for Lisp.

      Have you even seen such a beast?

      Multiple such beasts. Movitz is one such example. Sure, it's not particularly sophisticated, but that's because one guy is working on it. Popularity and suitability are two different things.

      --
      A deep unwavering belief is a sure sign you're missing something...
    69. Re:agreed 100% by be-fan · · Score: 1

      And researchers who want to build a general-purpose operating system that can be used in all of these scenarios are what? Shit out of luck?

      I think you've missed the point entirely. The whole point of this line of discussion was that such researchers were barking up the wrong tree. The microkernel itself becomes useless (and all the massive contortions required to support it), when the language itself is safe. The kernel ceases to exist as a seperate entity and becomes a seperate (though special, in that it can use unsafe operations) library. You stop worrying about protection domains, context switches, interprocedural communication, drivers in userspace vs kernelspace, how to implement paging, etc. Protection becomes fine-grained (per object), context switches become cheap, protection-domains become unnecessary, interprocedural communication becomes wicked fast (shared memory), and userspace vs kernelspace ceases to have any meaning. All you give up (in user code) is: pointers and manual memory management.

      For hard-real time, CPU-intensive uses, the second concession might be a deal-breaker. In that case, the microkernel has some semblence of relevance. However, for the vast majority of systems which don't need hard-RT, the concessions are minimal compared to the gains.

      --
      A deep unwavering belief is a sure sign you're missing something...
    70. Re:agreed 100% by be-fan · · Score: 1

      Right, which is why you stick to machine words.

      Right. If you're sticking to machine words, then who *cares* that C's rules for laying out structs is more predictable than what the Lisp optimizer might do to a struct? You can use a read/write oriented machine-word module in Lisp as easily as you can do the same in C!

      --
      A deep unwavering belief is a sure sign you're missing something...
    71. Re:agreed 100% by idlake · · Score: 1

      C provides direct access to datatypes which map almost directly to base valuetypes on commodity hardware. Good so far?

      No, sorry, that is not true. There are languages that make such guarantees, but C isn't one of them. People using C for such purposes are relying on non-standard (if common) features; the problem is that C never alerts you to this fact, and that these features can behave differently even between different versions of the compiler or with different flags.

      C itself makes no real runtime assumptions beyond the presence of a stack.

      The C language makes no guarantees whatsoever about real time behavior or memory management behavior. There may or may not be a stack. There may or may not be dynamic memory allocation even if you don't ever call "malloc". There may or may not be a garbage collector.

      That's just it, there effectively is no "C runtime" though

      C has as much or as little of a runtime as the compiler implementor happend to choose. GNU C happens to use a fairly simple runtime, as did K&R C, but other C compilers don't. Some have garbage collectors, for example. Try running your code under tcc in "safe" mode.

      Conversely, just like you can pick an implementation of C and use a stripped down runtime with it, you can do the same in Lisp, Modula-3, or Java, and people have. You can write code in those languages that never invokes the garbage collector.

    72. Re:agreed 100% by idlake · · Score: 1

      And here is the problem with this design: you seem to be ignoring the fact that it's running on a real machine without these high-level features

      That is an imaginary problem, since standard hardware can support runtime safety, garbage collection, and object-oriented dispatch efficiently.

      In some sense a microkernel is a workaround for safety issues: by decomposing functionality, you are isolating faults.

      Decomposition is good; using the MMU to decompose a large software system (kernel or otherwise) into modules is often bad.

      So you're idea is something like J-Kernel from the paper I linked to earlier, but actually running in kernel space and executing the whole system written in Java?

      No, it would most definitely not be like J-Kernel, which I consider impractical at this point. "My idea" is a system very much like the Linux or BSD kernel but written in a compiled language with garbage collection, runtime safety, well-defined primitives for accessing memory and hardware, and a simple object system. Such a kernel would be a drop-in replacement for Linux with no user visible changes (it could be system call compatible and user mode code could be written in any language whatsoever), and few changes in the way the kernel itself is developed. The main benefits would be easier testing, easier extensibility, fewer security problems, and better support for dynamically loadable modules.

      In real life, I think one might have to go there incrementally, by adding support for another systems programming language to the Linux and/or BSD kernel. A JVM/JIT wouldn't be my first choice, but it seems like the most realistic, and would be useful for intelligent packet filtering, security, file systems, network protocols, and some drivers. There has been some work on that (TeaseMe), but it will only take off when a good JIT is integrated.

    73. Re:agreed 100% by naasking · · Score: 1
      Let's keep this discussion in context. You expressed horror at the idea of an OS that depended on a single IL. What exactly is your horror in reaction to?

      Actually, I'm expressing horror at the consequences of interpreting a non-machine-native IL. Adequate performance entails implementing a full virtual machine with runtime code generation.

      At the level of the instruction set, compiling to CIL is really no different than compiling to PowerPC or x86. It's completely transparent from the point of view of the programmer.

      It's not the programmer I'm worried about. It's the end user I'm worried about; at the end of the day, he's the one taking the risk of running code on his machine. This system design leaves him vulnerable to local DoS attacks. If this approach could be made to work without adverse security consequences, and with more or less the same performance +/-10%, I'd be all for it.

      Without a GC? Likely not, but then again, we're not talking about removing the GC. That is not necessary to make a language suitable for writing kernels. We're talking about adding functionality to allow the specification of in-memory representation ("read-mem", "write-mem", "read-io-port", "write-io-port"). If C with an external function "read-io-port()" is still C, I don't see why the same isn't true for Lisp.

      No, we're really not talking about this. Let's revisit my main thesis. In order for a language implementation to be suitable for writing microkernels, it must:
      1. Provide sufficient control over low-level representation (which both C and Lisp do, either natively or through an FFI to lower-level code)
      2. Provide control over the runtime environment, with the explicit possibility of no runtime (which C does and Lisp does not)
      3. Have a ubiquitous, preferably free, native implementation (which both C and Lisp havel I just added 'native' qualifier to exclude VM OSes for simplicity)

      #2 is important because microkernels have no runtime, because many designs do not maintain state. The runtime features of Lisp et al are thus superfluous.

      Multiple such beasts. Movitz is one such example. Sure, it's not particularly sophisticated, but that's because one guy is working on it. Popularity and suitability are two different things.

      I took a gander. Looks neat, except once again, it drags aims to provide an entire Lisp runtime, GC included. That may be fine for some projects, but it's not good enough for all projects, particularly microkernels.
    74. Re:agreed 100% by naasking · · Score: 1

      Right. If you're sticking to machine words, then who *cares* that C's rules for laying out structs is more predictable than what the Lisp optimizer might do to a struct? You can use a read/write oriented machine-word module in Lisp as easily as you can do the same in C!

      Firstly, Lisp was merely an example, and not necessarily the best one. We are discusing high-level languages in general which perform field reordering optimizations; this is unacceptable for interfacing with hardware. As discussed, C forbids this, so it's already a little bit easier to talk to the hardware. That said, it is certainly possible to gain this same functionality with Lisp by calling into an FFI to a lower-level language if you like. All well and good, though you already lose Lisp's advantages, but fine, no matter, no argument. This was never the argument. If you recall, again, I had three criteria, and I have been most adamant that runtime was more a concern than a low-level interface with hardware.

    75. Re:agreed 100% by naasking · · Score: 1
      No, sorry, that is not true. There are languages that make such guarantees, but C isn't one of them.

      I never said C made any guarantees to this effect. All of my statements have been simple statements of fact. You keep confusing them with ideology. Don't read more into what I say than what I'm saying. Here is what I said:
      C provides direct access to datatypes which map almost directly to base valuetypes on commodity hardware.

      This is a statement of the current state of affairs. As things stand right now, commodity hardware are based around byte-addressable machines. Word sizes correspond very closely to C datatypes. Yes, there is room for intepretation in the standard, yes there is no guarantee of a fixed integer magnitude across compilers. These are ideological issues. The simple fact I am stating, is that every compiler of which I am aware, provides the C datatypes as closely mapped to the underlying native hardware word sizes as is feasible.

      Have I not repeatedly maintained, right from the beginning, that I am discussing a particular implementation of C, Lisp, etc.? One of my three main criteria for selecting a language in which to implement a kernel was "ubiquitous implementation that could provide the other two features".

      The C language makes no guarantees whatsoever about real time behavior or memory management behavior.

      Precisely. OS implementors don't want these policies in their languages. If they wanted their language to dictate policy to them, they'd choose Ada. It has portable semantics, interrupt handling, scheduling policies, even realtime extensions. But if they wanted to let languages dictate policy for them, they wouldn't be doing OS research would they?

      There may or may not be a stack.

      Sure, it depends on the host architecture naturally. But again, I'm discussing commodity hardware since we are discussing implementing a kernel on such hardware.

      There may or may not be dynamic memory allocation even if you don't ever call "malloc".

      Indeed, which is why it's important for the language to be useful without a runtime.

      C has as much or as little of a runtime as the compiler implementor happend to choose. GNU C happens to use a fairly simple runtime, as did K&R C, but other C compilers don't. Some have garbage collectors, for example. Try running your code under tcc in "safe" mode.

      Yes, but all these additional features are taken into account when selecting a candidate in which to implement the kernel. If tcc imposes undesirable features, then it will be similarly eliminated even though it implements the C standard. I don't think I've ever said anything to the contrary.

      What I have said, repeatedly, is that C:
      1. Has a ubiquitous, free implementation, that provides:
      2. Sufficient low-level control over representation
      3. Full control over runtime features

      You've just said more or less what I've been saying, yet you're disagreeing with me somehow. I'm having a hard time understanding.
    76. Re:agreed 100% by naasking · · Score: 1

      That is an imaginary problem, since standard hardware can support runtime safety, garbage collection, and object-oriented dispatch efficiently.

      It can, if we impose a type system on top of it. See LLVM for example. You might be interested in LLVA in fact. ("LLVA: A Low-level Virtual Instruction Set Architecture")

      Decomposition is good; using the MMU to decompose a large software system (kernel or otherwise) into modules is often bad.

      This is pure speculation. You have no real evidence to support this conjecture.

      "My idea" is a system very much like the Linux or BSD kernel but written in a compiled language with garbage collection, runtime safety, well-defined primitives for accessing memory and hardware, and a simple object system. [...] The main benefits would be easier testing, easier extensibility, fewer security problems, and better support for dynamically loadable modules.

      I'm still not clear whether you actually have processes, or they're simulated on the kernel VM, whether you use the MMU at all, or rely solely on the type-safe IL and code-generation (ie. the CPU is always in kernel-mode and the entire system is essentially running as one big VM).

      Also, I've pointed out a serious problem in this approach: DoS attacks. Perhaps this will be addressed when/if you can answer the above questions, but how do you account for resources and charge them to appropriate entities? Without proper accountability, you open up the system to DoS. The failure boundary for a JVM is the JVM itself. If a malicious object started accumulating memory without freeing it, the JVM would fail. What is the failure boundary in your system design?

      Let's say you find a way to handle the above memory accounting issue, what if the malicious object now accumulated garbage and freed it immediately, causing a great deal of work for the garbage collector? How is the CPU time tracked and charged to the object in question? Is each object individually schedulable? Does that now make them active objects, aka Actors? They get their own thread and communicate via messages? That fundamentally changes the JVM computational model. You may need a process model of some sort after all.

      Notice, the above accounting issues are all existing problems with just about every popular kernel in existence, particularly UNIX clones. EROS/CapROS has solved all of the above issues and Coyotos will inherit those benefits. I'm less familiar with L4, but I believe it too has solved the all of the issues; L4 is currently simply weak the security department compared to EROS/CapROS.

    77. Re:agreed 100% by be-fan · · Score: 1

      We are discusing high-level languages in general which perform field reordering optimizations;

      If, as you just said, you "stick to machine words" what does field reordering have to do with anything?

      As discussed, C forbids this, so it's already a little bit easier to talk to the hardware.

      But it says nothing about alignment, so even though its more predictable, its still completely useless. To put things into concrete terms, you can't use a struct like this to talk to hardware:

      struct foo
      {
              int rega;
              char regb;
              int regc;
      };

      Well, you can, but its completely unportable. Sure, at least you know that 'regc' is after 'regb', but you still don't know where 'regc' is.

      --
      A deep unwavering belief is a sure sign you're missing something...
    78. Re:agreed 100% by be-fan · · Score: 1

      Actually, I'm expressing horror at the consequences of interpreting a non-machine-native IL. Adequate performance entails implementing a full virtual machine with runtime code generation.

      Or a install-time compiler. Or a regular compiler with signed binaries.

      It's not the programmer I'm worried about. It's the end user I'm worried about; at the end of the day, he's the one taking the risk of running code on his machine. This system design leaves him vulnerable to local DoS attacks.

      How so? With the compile-at-install model, the only attack vector is defeating the protections in the trusted compiler. I don't think that's particularly easier that defeating the protections in a 'trusted' kernel.

      Provide control over the runtime environment, with the explicit possibility of no runtime (which C does and Lisp does not)

      Define "runtime". C++ has a runtime. C++ can and has been used for writing high-performance microkernels. Lisp can be used so it requires no bigger a runtime than C++. As long as you don't try to use EVAL in the kernel, you're set. All it requires is a GC, and I find your criteria for excluding the GC capricious and aribtrary --- one that only has merit in the specific case of RT kernels.

      --
      A deep unwavering belief is a sure sign you're missing something...
    79. Re:agreed 100% by idlake · · Score: 1

      C provides direct access to datatypes which map almost directly to base valuetypes on commodity hardware. This is a statement of the current state of affairs.

      No, it is not. C is a language and it has no facilities for low-level access. There are lots of C compilers that provide such access as implementation defined extensions (all in slightly different ways), but it's not part of C. EROS is a kernel written in one or two C compiler-defined dialects, not a kernel written in C. The distinction matters because you can do exactly the same thing in many other languages, and usually in better ways.

    80. Re:agreed 100% by naasking · · Score: 1
      No, it is not. C is a language and it has no facilities for low-level access. There are lots of C compilers that provide such access as implementation defined extensions (all in slightly different ways), but it's not part of C. EROS is a kernel written in one or two C compiler-defined dialects, not a kernel written in C. The distinction matters because you can do exactly the same thing in many other languages, and usually in better ways.

      1. And once again you are ignoring the simple statements of fact. There are no such compilers for other languages. If there is, show me one. All my statements were qualified in terms of available implementations. Show me a Lisp/Smalltalk/high-level language implementation right now, that permits interfacing with low-level hardware (either natively or through FFI), that permits no runtime environment (no GC, etc.), and that has a free, downloadable compiler that compiles to native code. I don't care that "it can be done"; I never disagreed with that. Show me where it's been done.
      2. Once again, I never said the C standard defined "facilities for low-level access". You cannot disagree with my statement because it is a simple observable fact: C provides direct access to datatypes which map almost directly to base valuetypes on commodity hardware.

        Commodity hardware: 32-bit and 64-bit desktop and server byte-addressable CPU architectures.
        C datatypes: char, int, long, long long (and unsigned variants)

        The above datatypes map directly to underlying byte-addressable word sizes on commodity hardware. You cannot deny this simple fact. This is important because it relates directly to what prompted this thread: why OS researchers chose C to implement microkernels. Answer: they deal with commodity hardware, they need a ubiquitous compiler, they need a language with sufficient control over memory layout and runtime. At the time, and even now, C, C++ and possibly Ada fulfill these criteria. If there is another one right now, show me.
      3. Re: C dialects
        This is completely silly. Yes, if you use gcc extensions like __inline__, it's no longer technically "C". That does not mean you cannot write a kernel in pure C even on gcc. All host-specific code is encapsulated in separate asm files and linked to the portable C. There is nothing preventing you from doing this. Yes, CapROS has some gcc-specific code. This is unavoidable with kernel-level software. A similar "Lisp-kernel" will also be written to a specific compiler with an FFI/host-interface of some sort. In conclusion, this distinction doesn't matter because it's universal.
    81. Re:agreed 100% by naasking · · Score: 1

      If, as you just said, you "stick to machine words" what does field reordering have to do with anything?

      Because we're in a new century. I/O isn't performed one word at a time anymore:

      Device command queues
      Example struct for SCSA1394 (see scsa1394_cmd struct)

      Field reordering breaks device communication.

      But it says nothing about alignment, so even though its more predictable, its still completely useless.

      And once again, as I've stated before, this is what pointer arithmetic is for. If you have alignment requirements, then you need a host-specific alignment-check. Yes, it's worse than Ada which can specify alignment portably. Unfortunately, Ada has other problems, but I've mentioned them before so I won't repeat myself.

      Well, you can, but its completely unportable.

      The number of non-portable features are small, and isolatable. Yes C forces you to do more work than other languages in this regard. Unfortunately, it's the only language with an implementation that has the other required features. Sucks, but there it is.

    82. Re:agreed 100% by naasking · · Score: 1

      Or a install-time compiler. Or a regular compiler with signed binaries.

      So the idea is to forbid installation and execution of arbitrary software? Only software signed with a verified compiler is permitted?

      How so? With the compile-at-install model, the only attack vector is defeating the protections in the trusted compiler. I don't think that's particularly easier that defeating the protections in a 'trusted' kernel.

      Well the only problem with this approach is that you'll have a hard time convincing people to run it. Little to no backwards compatibility (particularly binary in this case) makes people uneasy.

      All it requires is a GC, and I find your criteria for excluding the GC capricious and aribtrary --- one that only has merit in the specific case of RT kernels.

      Capricious and arbitrary? Why the hell would I want a GC when I'm not performing any allocation or reclamation of storage? What is its purpose? There is no point in it being there, it just unnecessarily bloats the kernel.

      Furthermore, the entire point of microkernels is to design a kernel that is small, performant and flexible enough to build almost any kind of system on top of it, realtime or not. Avoiding GC is a huge issue for microkernels, which is the very subject of this thread. If you can't exclude GC, that language implementation is unsuitable.

      Define "runtime". C++ has a runtime. C++ can and has been used for writing high-performance microkernels.

      Yes, because the runtime can also be excluded as with C. A "runtime" is a set of services provided at "runtime" over which the programmer need not and often cannot exert any control. It is a set of runtime assumptions from which the language itself cannot be divorced. Lisp cannot be divorced from dynamic memory allocation and automatic reclamation for example.

      And yes, C and C++ also have runtime assumptions, as we've gone over plenty of times (machine model), but the distinction is that these assumptions don't matter in practice, because they have little impact on the resulting code. C, C++ and Ada can run without memory allocation/reclamation. Lisp cannot.

      Lisp can be used so it requires no bigger a runtime than C++. As long as you don't try to use EVAL in the kernel, you're set.

      The problem is that Lisp requires a runtime period; the control over the runtime is not arbitrary. Many microkernels do not require a runtime, just as raw assembly does not require a runtime. C and C++, and to a lesser extent Ada, allow you to program (almost) portably, with no more practical assumptions than if you were programming directly in assembly. Does this elucidate my point? No other high-level language can be used this way yet. If there is, point it out.

    83. Re:agreed 100% by idlake · · Score: 1

      It can, if we impose a type system on top of it. See LLVM for example. You might be interested in LLVA in fact. ("LLVA: A Low-level Virtual Instruction Set Architecture")

      OK, so to summarize, you agree now that safe, garbage collected, object-oriented languages can give performance competitive with C, then. (It doesn't take a VM or a compiler/runtime more complicated than C, but that's a separate issue.)

      [using the MMU to decompose a large software system (kernel or otherwise) into modules is often bad.] This is pure speculation. You have no real evidence to support this conjecture.

      There is extensive evidence. If you want to check it for yourself, just try using DCOM or RMI to put some objects of an application into a separate address space. Not only is it a significant amount of work, it's also slow.

      I'm still not clear whether you actually have processes, or they're simulated on the kernel VM,

      As I was saying: "Such a kernel would be a drop-in replacement for Linux with no user visible changes". It would run Linux binaries, do scheduling and accounting in the same way, etc. The architecture, drivers, etc. all would have nearly identical code to what they have now. The main difference would be that unsafe uses of pointers would be eliminated by a better type system and that low-level access would happen through explicitly marked constructs.

      Let's say you find a way to handle the above memory accounting issue, what if the malicious object now accumulated garbage and freed it immediately, causing a great deal of work for the garbage collector?

      Despite the name, modern garbage collectors don't work that way; they are more of "live object collectors and categorizers". Furthermore, the cost of collection is amortized over the allocation: if a caller allocates a lot of objects, he has already paid his share of CPU time to free them, just like with malloc/free. Finally, the use of garbage collection doesn't give you license to abandon all principles of good storage management. In an environment like a kernel, you would likely use arenas, allowing you to recycle all resources associated with a user or a process instantly.

      Notice, the above accounting issues are all existing problems with just about every popular kernel in existence, particularly UNIX clones.

      Well, as a UNIX user, admin, and developer for a quarter of a century now, I can say that they are not practical problems in any real-world usage I have encountered. The practical problems with UNIX are lack of robustness against errors in dynamically loadable modules, difficulties associated with developing new kernel modules, and problems with module versioning.

    84. Re:agreed 100% by naasking · · Score: 1

      OK, so to summarize, you agree now that safe, garbage collected, object-oriented languages can give performance competitive with C, then. (It doesn't take a VM or a compiler/runtime more complicated than C, but that's a separate issue.)

      I never said it couldn't. I never said nor implied that C was the fastest language. Runtime-profiling and optimizations can often far outperform C. I'm a big fan of LLVM. That still doesn't mean that these features are, a) suited for microkernel development, b) are available for microkernel development.

      There is extensive evidence. If you want to check it for yourself, just try using DCOM or RMI to put some objects of an application into a separate address space. Not only is it a significant amount of work, it's also slow.

      This is anecdotal evidence. All this demonstrates is that DCOM and RMI are poor IPC implementations, not that IPC cannot be easy and fast.

      Finally, the use of garbage collection doesn't give you license to abandon all principles of good storage management. In an environment like a kernel, you would likely use arenas, allowing you to recycle all resources associated with a user or a process instantly.

      In my question I'm referring to malicious code which will not play by the rules of "good storage management". This code is actively seeking to break your system. In CapROS, you can run arbitrary code without fear of comprising your system or damaging your data because it supports confinement and fine-grained delegable resource management. You can't even do this in any other environment that I'm aware of (except some designs which were inspired by KeyKOS/EROS), Java/Smalltalk/etc. VMs included.

      Well, as a UNIX user, admin, and developer for a quarter of a century now, I can say that they are not practical problems in any real-world usage I have encountered. The practical problems with UNIX are lack of robustness against errors in dynamically loadable modules, difficulties associated with developing new kernel modules, and problems with module versioning.

      That's because nobody would dream of using insecure operating systems like UNIX and Windows in environments which require reliability, and secure collaboration among untrusted parties. Java has made some headway into this space (see Active Networks), but it too is limited (see the paper I referred you to on SCOLLAR; stack-walking security is inherently limited in distributed systems).

      UNIX is inherently based on a collaborative system design; it was not designed to support secure collaboration however. Adding full ACLs or a security system like SELinux only moves it partly in that direction (and it becomes an admistrator's nightmare).

      I understand your frustration with the same problems cropping up over and over again as programmer's continue to repeat past mistakes. Microkernels in unsafe languages do improve the situation somewhat. Microkernels in safe verifiable languages like BitC+Coyotos will solve a great deal more of these problems (more than your design I'd wager). The solution is not to drag all that cruft into a single monolithic kernel. But that's just my opinion; well, mine and a great deal of others who share it.

    85. Re:agreed 100% by idlake · · Score: 1

      Show me a Lisp/Smalltalk/high-level language implementation right now, that permits interfacing with low-level hardware (either natively or through FFI), that permits no runtime environment (no GC, etc.), and that has a free, downloadable compiler that compiles to native code.

      People have written operating systems in Modula-3 and Ada, so those would be obvious choices and they have free implementations. Of course, not many people know them, which is kind of a problem.

      In practice, I'd probably go with one or another Java implementation. If you like, you can use Java (but not the standard Java libraries) without a GC, but, as I mentioned, kernels should start using GC.

      I'd probably first look into using one of the FOSS VMs (IBM's is very good) and build around that. Failing that, a Java-to-C compiler or gcj would be other possible choices.

      As a last resort, I might consider using a subset of C++ with an exact garbage collector (they can be written as libraries) and enforcing the use of relatively safe constructs through a (custom written) style checker.

      You cannot disagree with my statement because it is a simple observable fact: C provides direct access to datatypes which map almost directly to base valuetypes on commodity hardware. Commodity hardware: 32-bit and 64-bit desktop and server byte-addressable CPU architectures. C datatypes: char, int, long, long long (and unsigned variants)

      The C language makes few guarantees about how machine datatypes map onto C datatypes. The mapping may even change according to compiler versions and compiler flags, and the mappings are often not the "obvious" ones.

      Yes, if you use gcc extensions like __inline__, it's no longer technically "C". That does not mean you cannot write a kernel in pure C even on gcc. All host-specific code is encapsulated in separate asm files and linked to the portable C.

      Even something as simple as accessing the first byte of an int through a char pointer is undefined. And your remarks highlight another problem with C: its users don't even realize when they are using undefined constructs.

    86. Re:agreed 100% by naasking · · Score: 1
      People have written operating systems in Modula-3 and Ada, so those would be obvious choices and they have free implementations. Of course, not many people know them, which is kind of a problem.

      1. Modula-3: whether or not you believe me, the fact remains that garbage collection is unsuitable for microkernels. Can't use Modula-3.
      2. Ada: a promising candidate. Unfortunately, in my tests about a year ago it had some binary-bloat problems which hinder its use in a microkernel. That and gnat is currently not available for amd64 which is my current machine.


      The C language makes few guarantees about how machine datatypes map onto C datatypes. The mapping may even change according to compiler versions and compiler flags, and the mappings are often not the "obvious" ones.

      I know that. We've been over it before. It's also not what I was saying. I was making an observation. It still stands. We are not talking about the 'abstract standard', we are talking about the reality of implementing a kernel right now. The reality is, you'll have to pick a particular compiler to write a kernel regardless of the implementation language. I'd wager any of these compilers have efficient, direct mappings between C types and underlying architecture value sizes.

      Even something as simple as accessing the first byte of an int through a char pointer is undefined.

      Because the "first byte of an int" depends on the endianness of the underlying machine. This is the identical situation encountered under assembly language: you are exposed to the details of the architecture. This is why I said C is barely a step above assembler. A well-written kernel (micro or monolithic) will generally consist of: effectively 100% portable C, platform-specific C, platform-specific assembly. I see no reason why the portable C can't conform to the standard.

      And your remarks highlight another problem with C: its users don't even realize when they are using undefined constructs.

      This is a problem of ignorance, not the standard or the language itself; people who can't be bothered to understand the language they're using have no business writing kernels.

      Also, very few programs are 100% portable across all architectures and compiler implementations. Show me a serious program that is 100% portable across Lisp implementations, particularly a program that uses FFI.
    87. Re:agreed 100% by idlake · · Score: 1

      Because the "first byte of an int" depends on the endianness of the underlying machine.

      Or you may get a completely unrelated value, an incorrect value every 4 billion accesses, or a crash.

      This is a problem of ignorance, not the standard or the language itself

      It's also a problem of software engineering because it's impossible looking at a piece of C code to determine if and where it uses unsafe or unportable constructs. That causes major problems when porting systems code (but I gather CapROS is Intel/gcc only at this point).

      This sort of difficulty is completely unnecessary--it buys you nothing in terms of performance or expressiveness. It's a historical accident. It would be trivial to have a language that is in every respect like C but that cleanly separates its portable and defined constructs from implementation or undefined constructs.

    88. Re:agreed 100% by idlake · · Score: 1

      In my question I'm referring to malicious code which will not play by the rules of "good storage management".

      Whatever constraints you impose on storage management without GC you can impose with GC. In fact, GCs are arguably inherently better at enforcing real-time or storage management constraint than manual allocators (Sun's tribulations with Java notwithstanding--a poor GC can indeed be a headache, but so can a poor malloc).

      UNIX is inherently based on a collaborative system design; it was not designed to support secure collaboration however.

      UNIX has been, and continues to be, widely used for large multiuser systems with sometimes thousands of untrusted and malicious users. It really works for that application.

      Microkernels in safe verifiable languages like BitC+Coyotos will solve a great deal more of these problems (more than your design I'd wager). The solution is not to drag all that cruft into a single monolithic kernel. But that's just my opinion; well, mine and a great deal of others who share it.

      Well, it's good that we do agree as much that writing a kernel in a new language is a good idea. The methodology and design of EROS/Coyotos is a separate discussion.

    89. Re:agreed 100% by naasking · · Score: 1

      Or you may get a completely unrelated value, an incorrect value every 4 billion accesses, or a crash.

      I suppose you're referring to uninitialized variables. Indeed, C imposes no restrictions on initialization, just like assembly. You are free to be as safe, or unsafe as you like within the limits provided by the language implementation.

      It's also a problem of software engineering because it's impossible looking at a piece of C code to determine if and where it uses unsafe or unportable constructs.

      I'm not sure this is entirely accurate. The class of unportable constructs is fairly well-known. Pointer casting for instance. Sticking to the straight C dataypes with no casting is generally pretty safe.

      That causes major problems when porting systems code (but I gather CapROS is Intel/gcc only at this point).

      Yes, x86-gcc only I believe.

      This sort of difficulty is completely unnecessary--it buys you nothing in terms of performance or expressiveness. It's a historical accident. It would be trivial to have a language that is in every respect like C but that cleanly separates its portable and defined constructs from implementation or undefined constructs.

      For the most part, that's very likely. But it's not here today, and that's all that matters when choosing a language here and now. Just cross your fingers that they get BitC right.

    90. Re:agreed 100% by naasking · · Score: 1

      Whatever constraints you impose on storage management without GC you can impose with GC. In fact, GCs are arguably inherently better at enforcing real-time or storage management constraint than manual allocators (Sun's tribulations with Java notwithstanding--a poor GC can indeed be a headache, but so can a poor malloc).

      My point was that binary modules linked with the kernel or interpreted in the kernel VM would share the same heap as the kernel itself. Allocating from this heap continually in a malicious cycle without freeing any of it is a trivial DoS attack. You have to start inventing ad-hoc quota mechanisms to start trying to limit the damage, but I've seen no accounting system that is flexible enough for all cases. If we're dealing with pure open source, this is less of an issue due to code "peer-review", but it's definitely a problem on Windows. If each allocation triggers even a brief collection cycle, the problem becomes even worse because you now also have a DoS attack against the scheduler since nothing else can run while we're stuck in kernel mode. Ugh, monolithic kernel designs are just a huge mess.

      By pushing everything to user-space, microkernels export the memory management policy out of the kernel and make it fully pluggable. Thus, there is no global vulnerability to DoS, there is only a local vulnerability on a particular memory manager which may only be shared by a subset of the whole system; thus only that subset may be affected by an attack (depending on how resilient the design is). CapROS furthers this design with its single-level storage model, and a hierarchical Space Bank scheme, with potentially one Space Bank assigned per object (object-level granularity in storage accounting). You're clearly a fan of object-oriented design, and the CapROS architecture is fully object-oriented, Actors-style, right down to the bits written to disk; the object-model lacks only inheritance.

      Regardless of how much better GC is, you simply cannot do better than a fully-pluggable memory management system.

      Furthermore, since every extension to the system is a user-mode process, everything is schedulable, nothing ever blocks or stalls in the kernel, so now we can even provide realtime guarantees. Everything becomes simpler with microkernels. Only the programming the kernel becomes a bit harder.

      UNIX has been, and continues to be, widely used for large multiuser systems with sometimes thousands of untrusted and malicious users. It really works for that application.

      No, they are not malicious users, though they may be untrusted users. If they were actually malicious, that system would be taken down within minutes of it being brought up; certainly not the mark of a secure or reliable system architecture.

      Well, it's good that we do agree as much that writing a kernel in a new language is a good idea.

      It's a great idea, especially with the state of theorem proving being as advanced as it now is, I have high hopes for Coyotos. I believe our only point of disagreement was the suitability of C as a kernel language right now (due to lack of better options), and the benefits of the microkernel design. Having a safer language in which to write kernels is always a good idea. I mean really, why the hell wouldn't you want a better/safer language right?

    91. Re:agreed 100% by be-fan · · Score: 1

      Um, that struct from the Solaris code isn't portable to an Alpha-based Cray (which are ILP64 machines). It also assumes alignment rules all over the place. On top of all that, it'd take me maybe a day to come up with a Lisp macro that let you specify a byte-accurate "data packet" format, without all the unportable assumptions regarding the size and alignment of ints and chars.

      --
      A deep unwavering belief is a sure sign you're missing something...
    92. Re:agreed 100% by idlake · · Score: 1

      suppose you're referring to uninitialized variables. Indeed, C imposes no restrictions on initialization, just like assembly. You are free to be as safe, or unsafe as you like within the limits provided by the language implementation.

      No, I'm referring to the fact that the effect of dereferencing a pointer to an int as a char pointer is undefined, even if the int is initialized properly. All those things I mentioned are effects you might plausibly see even on an ANSI conformant C compiler for Pentium.

      For the most part, that's very likely. But it's not here today, and that's all that matters when choosing a language here and now. Just cross your fingers that they get BitC right.

      I don't have much hope for BitC; it may be technically alright, but if it doesn't look vaguely like something people know, it won't get used. I think the most likely next language for a widely used kernel will eventually be a Java-to-C translator, a C#-to-C translator, a safer variant of Objective C developed by Apple, or possibly ANSI C 2015 or something, where people finally clean up the mess.

    93. Re:agreed 100% by idlake · · Score: 1

      My point was that binary modules linked with the kernel or interpreted in the kernel VM would share the same heap as the kernel itself.

      There is no such thing as "the heap" in a modern garbage collected system. Modern garbage collectors have variable numbers of regions and areas that are utilized for different objects. These regions are utilized adaptively by the garbage collector and optionally under supervisor or program control. You can limit their sizes, their growth, their allocation rates, their placement in memory, or whatever else you can imagine.

      You have to start inventing ad-hoc quota mechanisms to start trying to limit the damage, but I've seen no accounting system that is flexible enough for all cases.

      These techniques were invented in the 1970's and 1980's. It really sounds to me like EROS is reinventing a limited form of modern memory management techniques, and not doing a good job at it.

      Regardless of how much better GC is, you simply cannot do better than a fully-pluggable memory management system.

      Well, I think one can certainly do a lot better than a fully-pluggable memory management system based on a microkernel architecture, both in terms of functionality and in terms of performance.

      No, [UNIX users on multiuser machines] are not malicious users, though they may be untrusted users. If they were actually malicious, that system would be taken down within minutes of it being brought up; certainly not the mark of a secure or reliable system architecture.

      A UNIX machine with hundreds of CS undergraduates has malicious users on it: all the DoS and security hacks you can imagine have been tried on it. If it survives that (and it does), it's good enough for most applications. It's not secure because of any principles, it's because in the decade after BSD and SunOS got released, people spent huge amounts of time fixing bugs and problems.

    94. Re:agreed 100% by seebs · · Score: 1

      Where do you get the idea that people would get laughed at for writing a complex modern application in C? There's a lot of pure C still being written.

      --
      My blog: http://www.seebs.net/log/ --- My iPhone/iPad app: http://www.seebs.net/seebsfrac/
  63. Thank-you "It's fast enough" Lemmings by istartedi · · Score: 1

    Still.. as fast as modern computers are I think we may be reaching a point where raw speed is less important

    All else equal, the faster code is better. Either you can actually do things faster, or you can run the faster code on cheaper hardware. Thank-you, lemmings, for giving those of us who know that performance matters an edge against vast numbers of you who've been duped into believing it doesn't.

    --
    For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
    1. Re:Thank-you "It's fast enough" Lemmings by naasking · · Score: 3, Interesting

      All else equal, the faster code is better.

      Sure, but all things are not equal, and an improvement that obviously improves performance, often doesn't. OS programming isn't quite the same as pure user-level programming, so optimizations aren't so clear-cut.

      People often assume that monolithic kernels are faster than properly designed microkernels due to less supervisor-user context switching, but this often isn't the largest cost in modern systems. For instance, monolithic kernels can't/don't schedule their interrupt handling through the common scheduler, so they're nearly impossible to use for realtime.

      Reliability, flexibility and security is also dramatically improved in decomposed microkernel designs, so really, suffering a 5-10% performance penalty to gain an extra few 9's in reliability (99.99% uptime as opposed to 99%) is often worth it IMO.

    2. Re:Thank-you "It's fast enough" Lemmings by MikeFM · · Score: 1

      It's often cheaper to throw more hardware at the problem than pay for more downtime because of poor reliability. Hardware is cheap. I'm fairly poor and I have a couple dozen systems laying around most of which are fairly new. Most problems are such that the extra 5% gained from a monolithic design won't matter anyway as more time is spent with the cpu waiting for one thing or another.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
  64. Recipe for Karma by Anonymous Coward · · Score: 0

    Holy crap, I really need to try this new style of karma whoring, it's like taking candy from a blind baby.

    1. Wait for new /. story.
    2. Post template "Thank you <someone> for <topic>, it has really done X, Y and Z for me." comment.
    3. Insightful++;
    4. Karma++;

  65. You think you can lift that tv? by NIN1385 · · Score: 0, Offtopic
    Not sure why, but this article made me think of the Mandelbaums from Seinfeld.

    Izzy Mandelbaum: Your son's pretty funny, Morty. He oughta be a comedian. Jerry: Actually, I am a comedian. Izzy Mandelbaum: That's not funny.

    --

    If carrots got you drunk, rabbits would be fucked up. - Comedian Mitch Hedberg R.I.P. 03/30/68-2/24/05
  66. Microkernels... by Dwonis · · Score: 2, Insightful
    yes, he still thinks that micro-kernels are more reliable than monolithic kernels

    Of course he does. Everyone does. The old argument between Linus and Andy was never about reliability. It was about *practicality* and *efficiency*. Microkernels usually incur a lot of overhead. Andy thought the overhead was worth it; Linus didn't.

    1. Re:Microkernels... by argent · · Score: 1

      There are no fundamental reasons why microkernels must inherently incur more overhead than monolithic kernels. There are several reasons why traditional academic microkernels like Minix have poor performance, but in the real-time world things are very different.

      1. Academic kernels typically establish a separate protection domain for every process. This makes them easier to reason about and implement, but it means that every message requires switching page tables. This is expensive, but no more necessary than having a separate kernel layer to match each layer of the ISO protocol model.

      2. Academic kernels typically use messages as the only IPC mechanism, eschewing shared access to shared resources like buffer pools. This doesn't actually hurt your traditional microkernel all that much, because you can't really take advantage of this until you solve the first point.

      3. Avoiding bottlenecks can be difficult, and at least needs explicit design. If the file system is a single thread with no internal request management or queuing, then only one process can be reading from the file system ar a time. In a traditional kernel you automatically get a separate process for each synchronous request, so when it's blocked on some resource other processes can continue to use the file system.

      Basically, Minix performance was poor because it was designed as a teaching tool, so it avoids muddying the waters by throwing everything you need to do to make a microkernel really cook away. Its limitations are similar in origin to the limitations in Pascal. Would you argue against strong typing and type checks because Pascal's type system doesn't include a variable length array? Or against structured programming because Pascal doesn't support separate compilation and linking?

      Finally, microkernels are not automatically more reliable than monolithic kernels, they just have failure modes that are normally easier to diagnose and trace.

    2. Re:Microkernels... by RexRhino · · Score: 1

      A lot of this is also a bias in the machine hardware... if computers were designed for a microkernal OS, that would solve a lot of the problems with using a microkernal OS.

  67. Answer from someone who was there by metamatic · · Score: 3, Interesting

    Well, since nobody else has posted a very informative answer...

    Linux is based on MINIX. It was built on MINIX, using MINIX. It started off as Linus's weekend hack to build a 386-specific replacement kernel, so he could have MINIX with pre-emptive multi-tasking and memory protection. Andy Tanenbaum didn't want to make MINIX 386-specific because, like the NetBSD and Debian folks, he was trying to make something that would be portable to lots of different hardware. (Like the Atari ST I was running it on.)

    Then there was the big flamewar over monolithic kernels vs modular microkernels. Linus went off in a huff and turned Linux into a complete OS by ripping out all the MINIX and adding all the GNU stuff instead. Then over the years he introduced a modular kernel and made it portable to multiple architectures, basically admitting he was wrong but never saying so.

    At that point, Linux started to become usable as an OS. And in the mean time, MINIX had been killed by toxic licensing policies of the copyright owner (not Andy Tanenbaum). That, and the x86 architecture had expanded to 90% of the market. So, we arrived at the situation we have today, where MINIX is largely forgotten, and we have a MINIX-like Linux with all the mindshare.

    And now, ironically, Andy Tanenbaum has made MINIX 3 only run on the x86. So perhaps he and Linus can now both admit they were wrong in major respects, and make friends?

    --
    GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
    1. Re:Answer from someone who was there by kl76 · · Score: 4, Interesting

        It started off as Linus's weekend hack to build a 386-specific replacement kernel


      There was already a 386-specific 32-bit version of the MINIX kernel around at the time; it was called MINIX-386, unsurprisingly enough, and was widely used in the MINIX hacker community.


      Linus went off in a huff and turned Linux into a complete OS by ripping out all the MINIX and adding all the GNU stuff instead.


      There wasn't ever any MINIX code in Linux - there couldn't have been, as MINIX was a commercial product at the time. What there was, was plenty of minor MINIX influences on the design (lack of raw disk devices, "kernel", "fs" and "mm" subdirectories in the kernel source, Minix-compatible on-disk filesystem format, major/minor device numbers etc.) but no major ones (ie. the microkernel paradigm).


        And in the mean time, MINIX had been killed by toxic licensing policies of the copyright owner (not Andy Tanenbaum). That, and the x86 architecture had expanded to 90% of the market.


      Well, yes, you had to pay for MINIX, but there were no free OSs to speak of in those days. The reason MINIX seemed to disappear was that most of the MINIX hacker types were using MINIX because it was the closest thing to real UNIX they could afford. Once Linux appeared, as open source, with its simple goal of being a UNIX clone (rather than a model OS for teaching purposes, as MINIX was meant to be), it was inevitable that most of the MINIX hacker community would migrate en masse.
    2. Re:Answer from someone who was there by kl76 · · Score: 1

      And now, ironically, Andy Tanenbaum has made MINIX 3 only run on the x86.


      From the front page of www.minix3.org:


      Ports to the ARM7 and PowerPC are underway.
    3. Re:Answer from someone who was there by petermgreen · · Score: 1

      while there is ucLinux, standard linux is dependent on a processor with a mmu. Were there any other such processors easilly availible when linux started.

      Also sometimes its easier to get stuff working first with as little complications as possible and refactor it later once you understand whats going on and where you need abstraction.

      --
      note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
    4. Re:Answer from someone who was there by metamatic · · Score: 2, Informative

      Linus went off in a huff and turned Linux into a complete OS by ripping out all the MINIX and adding all the GNU stuff instead.

      There wasn't ever any MINIX code in Linux

      Linux-the-kernel never contained MINIX code, but Linux-the-OS was Linux-the-kernel running inside an OS made of MINIX code. A new Linux-the-OS was made by ripping the MINIX bits out and replacing them with the OS bits from GNU and newly written stuff as necessary.

      And I don't remember ever hearing about MINIX-386--but then again, as I mentioned, I wasn't using x86 hardware...

      --
      GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
    5. Re:Answer from someone who was there by metamatic · · Score: 1

      There were other CPUs with an MMU. The problem was that not all commonly used CPUs had one, or had one that worked properly.

      One big problem was the 68000 used in the Mac, Amiga and Atari ST. Until the 68030, certain traps resulted in a loss of state, effectively making it impossible to implement fully pre-emptive multi-tasking and memory protection. (There was at least one obscure UNIX box that worked around the problem by running the same code on two 68000s simultaneously, and having one peek at the other after an interrupt to find out what had been lost.)

      I gather the 8088 thru 80286 had similar problems, but I never learnt machine code for those so I'm just going by hearsay there.

      At the time, the combination of Mac, Amiga and Atari ST plus 8088, 8086 and 80286 was a sizeable chunk of the installed base compared to 80386. Particularly at universities, which couldn't afford to go out and rip and replace all their hardware, and couldn't demand that CS students all have expensive new computers.

      --
      GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
    6. Re:Answer from someone who was there by OwnedByTwoCats · · Score: 1

      Sigh.

      So much misinformation, so little time.

      Apple introduced Macintosh computers based on the 68030 in 1988 (Mac IIx, Mac IIcx). Compaq introduced the 386 series of Deskpro computers earlier, in 1987. Given that machines had a 3 or 4 year lifespan, End-of-lifed machines with MMUs were available in 1991, when Linux was introduced.

    7. Re:Answer from someone who was there by ChadN · · Score: 1

      There was at least one obscure UNIX box that worked around the problem by running the same code on two 68000s simultaneously, and having one peek at the other after an interrupt to find out what had been lost.

      I believe multiple vendors used the dual 68000 trick to help with memory protection, including Sun 1 and Apollo workstations, and some IBM computers.

      --
      "It's overkill, of course. But you can never have too much overkill." - Anonymous Slashdot Coward
    8. Re:Answer from someone who was there by metamatic · · Score: 1

      I didn't say Macs with MMUs weren't available, I said that Macs without MMUs made up a substantial proportion of the installed base. In 1991 I had a 68000 based Mac, and all the Macs at college were 68000 based as well.

      --
      GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
  68. Linux would originally boot from Minix by Anonymous Coward · · Score: 0
  69. BeOS and AmigaOS are microkernels by irritating+environme · · Score: 1

    These are (according to Wiki) microkernels. Haven't ran either of them, and as I understand at the time, neither of them "sucked", they may have lacked a sufficient community to engender commercial success.

    I've never heard of BeOS as "sucking", just that it didn't have software. And from an OS "feel", it was powerful, responsive, and efficient, and implemented some relatively revolutionary features for an OS

    AmigaOS was, for its time, quite advanced. Eventually the behemoth Microsoft compensated, but if these two OSes hardly seemed flawed from a fundamental OS design, more brutal economic realities.

    --


    Hey, I'm just your average shit and piss factory.
    1. Re:BeOS and AmigaOS are microkernels by naasking · · Score: 1

      Neither BeOS no AmigaOS are microkernels. They're probably more compact than the monolithic Linux architecture, but still a far cry from a true microkernel.

    2. Re:BeOS and AmigaOS are microkernels by ankarbass · · Score: 1

      Yes, but you can't have a conversation about operating systems without at least one amiga fanboy piping in about how good the amiga OS was. If I remember correctly, it could multitask. That is, it could display one grainy image of a reflective ball while another one rendered. Oh, and you could program it in basic. What more do you want from an OS?

      --
      Wanted: Clever sig, top $ paid, all offers considered.
    3. Re:BeOS and AmigaOS are microkernels by MikeFM · · Score: 1

      I never really cared for either (BeOS was shit ugly IMO) but I'll agree that neither sucked. I'll have to look for some design studies to see how much the microkernel designed helped or hurt them. BeOS may have been able to become a major player if the top dogs there hadn't been so sure of how great they were. To bad they didn't go opensource early on.

      --
      At what price learning? At what cost wisdom? The price is a man's peace of mind, and the cost is his life.
    4. Re:BeOS and AmigaOS are microkernels by LocalH · · Score: 2, Funny

      The only thing worse than an Amiga zealot is an anti-Amiga zealot.

      --
      FC Closer
    5. Re:BeOS and AmigaOS are microkernels by Anonymous Coward · · Score: 0

      fanboy!

    6. Re:BeOS and AmigaOS are microkernels by zoontf · · Score: 1

      BeOS drivers were user space, as were all services. This had is weaknesses in that some of the user space programs were not written as stably as they should have been (net_server), but hey, when they crash, you just launch the user-space program again, and that thing is restarted. I don't think Minix's approach to drivers is really so very different from BeOS' approach. It is unfortunate that so few people were honestly exposed to BeOS - it was a great leap forward at its time and for about 10 years after its time.

  70. And what hardware does it support? by markdj · · Score: 2, Insightful

    Where does it list the hardware it supports? I'm not talking about CPU or HD or CD. I'm talking about network card, video card, DVD, printer, etc. In my opinion the biggest problem with UNIX/LINUX/MINIX type OS's is the problem of hardware support. Since most hardware shops don't have the resources to create and test drivers for multiple OS's, they concentrate on Windows and let someone else come up with drivers for other OS's. That leaves the UNIX/LINUX/MINIX type OS's constantly behind the curve since they have to have someone create drivers after the hardware is released and by the time the driver is tested and stable, the hardware is obsolete.

  71. System Requirements by mnmn · · Score: 3, Interesting

    16MB ram in the requirements... all I can say is WOW.

    This is supposed to be a simple OS, much simpler than the first version of Linux.

    ucLinux can run on 1MB. Older versions can be trimmed enough to run in 200kb even but thats pushing it. Minix now requires 16MB!!! Thats more than ANY BSD out there.

    I was interested in running it on MCUs with small ram and flash. Trimming down uCLinux to the extreme uses 200kb of ram by the kernel and one shell. eCos requires under 64kb for simple compilations. eCos is POSIX for the most part, but theres hardly any schedulers in there, and no real filesystem drivers or calls.

    Minix is a full OS, but being that simple, I expected the kernel to fit in 64kb ram. I guess I'll use NetBSD as a simpler OS to study before graduating on to Minix 3.

    --
    "Give orange me give eat orange me eat orange give me eat orange give me you." -Nim Chimpsky
    1. Re:System Requirements by argent · · Score: 4, Informative
      16MB ram in the requirements... all I can say is WOW.
      What hardware do I need to run MINIX 3?<br>
      You need an Intel 386 or higher with 4 MB of RAM, an IDE hard disk with 100 MB of free disk space, and an IDE CD-ROM for booting.
    2. Re:System Requirements by johansalk · · Score: 1

      I don't see why he's complaining; where can he still find a PC with even 16MB RAM?

    3. Re:System Requirements by argent · · Score: 1

      where can he still find a PC with even 16MB RAM?

      Embedded systems often have less than that.

  72. Debugging a high performance messaging system by RevMike · · Score: 3, Informative
    That'd be more convincing if I could see a microkernel OS that didn't suck. The theory is great.. sort of like object oriented programming.. but doesn't always work out. The biggest problem seems to be that that extra layer of abstraction slows things down (which makes sense really).

    Actually, the bigger problem with microkernel is debugging. When passing messages around inside an OS, there is a potential for lots of race states and the like. The trick to microkernel is getting the messages to run around as fast as possible without adding synchronization points. Every synchronization point slows the system a little, but makes the system a little more stable. Once you've optimized the system for performance, and small change to any module the kernel talks to can throw the whole thing out of balance, and you need to go back and debug the race states and retune the code.

    In short, a kernel can be fast, flexible, or reliable. You can have two, but it is really difficult to have three. Macro-kernels are generally fast and reliable. Micro-kernels can be fast and flexible, flexible and reliable, but rarely are they fast and reliable.

  73. Secret weapon by mattr · · Score: 1
    Some people (at least one) will say:

    All you need is ColorForth. To be clear, this IDE driver's kind of compact.

    Some more links.

  74. So is GOTO by Urusai · · Score: 1

    It sure is nice to be able to jump from any point in code to another. I also like to allocate all the registers for special internal functions ("global" registers), leaving only EAX for public use (except when used as a return value). Oh yeah, and I love how C lets me have all the speed an elite hacker like myself needs, yet leaves me unencumbered with the last 30 years of advancement in computer science. Likewise, Linux lets me pretend I'm hacking on a PDP-11 in the basement of MIT...I sure hate virtual addressing, it just slows a computer down (you VAX nerds know what I mean).

  75. Hurd, L4 = EROS? by Anonymous Coward · · Score: 0

    I think it'll be a while before Hurd comes out, since they appear to be switching from the L4 microkernel to the EROS/Coyotos model.

  76. only 386 or higher by Anonymous Coward · · Score: 0

    Although I suppose it's somewhat trivial at this point, I see that Minix 3 doesn't support any x86 processor lower than a 386, whereas previous versions supported everything from an 8088 and up.

    It's a bit sad to see that support dropped, although I can see why in this day and age. Although, if you can still find an old 286-based PS/2 kicking around, it would be nice to run the latest and greatest version of Minix on it :)

  77. Why the X vs Y arguments? It's just another tool by ishmalius · · Score: 1
    Why must Slashdot comments always degenerate to "We are cool. You suck!" ? There should be less NAND and NOR, more AND and OR when considering the many varieties of software available in Open Source. Windows vs BSD vs Linux vs Whatever, Gnome vs KDE, mice versus trackballs... these arguments are getting old and tired. People should learn and embrace the spectrum of technologies, and select the best ones for the given task at hand.

    Minix's abilities are neither worse nor better, just different. That is the charm.

    And technologies can benefit from the others' ideas. For example, many Linux distros have PnP and WLAN-NG, which have architectures in common with microkernels: a pluggable API with dynamically loaded modules.

  78. So this means... by Spy+der+Mann · · Score: 1

    ...that Minix is now a better Linux than Linux? :-S

  79. down by pooly7 · · Score: 1

    They're website is down... I hope they're not using Minix as the OS ! http://toolbar.netcraft.com/site_report?url=http:/ /minix3.org Oh, no it's Solaris 9. Sounds bad...

  80. Globule? by Thuktun · · Score: 4, Funny

    Disclaimer: I am the chief architect of Globule, the experimental content-distribution network used to host www.minix3.org.

    Translation: "Please load-test my network."

    1. Re:Globule? by Winterblink · · Score: 1

      In the absence of moderation points: LOL

      --
      "I'm a leaf on the wind. Watch how I soar."
      -Hoban Washburn
  81. agreed 50% by PAPPP · · Score: 1
    I agree that old C-based OS design has issues, and that OOP design should be applied to OSes, for speed, security, and clarity reasons. However, it is my strong personal opinion that bytecode is never the right solution. To explain by metaphor :
    • Writing an OS in C is like rigging a ship starting from hemp. It takes forever, forces you to reinvent the wheel, and adds whole new layers of potential for accidents.
    • Writing an OS in Java (or C# or any bytecode language) is like rigging a ship with twine because you can hang yourself with rope. (also note: both are impractical, twine isn't strong enough, and bytecode needs an interpreter)
    • Writing an OS in an object-oriented memory protecting language (like C++) makes sense.
    1. Re:agreed 50% by abradsn · · Score: 1

      I agree, accept I think object pascal (instead of C++) is better because it helps to keep people from mis-using pointers as much. C++ is really just a kludge on top of C.

    2. Re:agreed 50% by Anonymous Coward · · Score: 0

      Or more likely, making a ship with C++ is like making everything from rope because boards are "too inflexible" and "can't be bent into a pretzel". Making a ship only from Java would be like making it only out of boards... even the rigging out of wooden chain-lengths or something.

      That's why you combine the two: C rope for the rigging and Java boards for the main body. Nice analogy.

    3. Re:agreed 50% by tom8658 · · Score: 1

      C is a very good language for writing an operating system assuming that you are competant enough in C to get the job done, because it is close(ish) to the machine. C++ isn't a bad choice either, because really it's just C with some memory protection and i/o streams tacked on. Not a lot of extra overhead and a slight savings in debugging time.

      The problem is that C is what most OSS is written in (think Linux and most of its executables), so systems programmers (except those working for M$), use C. While a migration to C++ wouldn't hurt, it probably wouldn't help much either. You can still shoot yourself in the foot with pointers, and STL isn't really good for writing operating systems (although I've never tried).

      On the other hand, writing an operating system in Java (or any bytecode language) is far from ideal. Yes, most everything is wrappered so it's very easy to write safe code, but why waste so much potential power running a native Bytecode -> x86 interpreter?

      Its really a tradeoff of code overhead vs. developer time. Unless you're writing an OS on an Acorn RISC chip that executes Java bytecode natively.

    4. Re:agreed 50% by tom8658 · · Score: 1

      I meant ARM chip.

    5. Re:agreed 50% by Anonymous Coward · · Score: 0

      What planet have you been living on? Java interpreted? Good lord, have you ever heard of something called a compiler, like say gcj? Not to mention that Java hasn't been interpreted for a decade.

      Serious Java with a few tweaks is perfectly fine. C# is fine as-is.

    6. Re:agreed 50% by Eli+Gottlieb · · Score: 1

      Amen to that, and join up brother!

      Pascal OS Dev

    7. Re:agreed 50% by Eli+Gottlieb · · Score: 1

      An appropriate language named Object Pascal was mentioned just above the parent's post.

    8. Re:agreed 50% by be-fan · · Score: 1

      C++ isn't a memory protecting language. It's all the OO overhead of Java, with none of the automatic memory-managment advantages, and with the optimizer-defeating pointer-induced ambiguity of C.

      --
      A deep unwavering belief is a sure sign you're missing something...
    9. Re:agreed 50% by be-fan · · Score: 1

      C is a very good language for writing an operating system assuming that you are competant enough in C to get the job done, because it is close(ish) to the machine.

      C is nothing like the machine. It was back in the PDP-11 days, but not now. C assumes a scaler execution model (with no parallelism to speak of). CPUs are superscaler, vector, and multicore. C assumes unprotected linear memory, while modern CPUs (like the K8), have protected, non-uniform memory.

      --
      A deep unwavering belief is a sure sign you're missing something...
  82. minix3.org down =( by xate · · Score: 1
    Service Temporarily Unavailable

    The server is temporarily unable to service your request due to maintenance downtime or capacity problems. Please try again later.

    Additionally, a 503 Service Temporarily Unavailable error was encountered while trying to use an ErrorDocument to handle the request.

    Apache/2.0.54 (Unix) mod_ssl/2.0.54 OpenSSL/0.9.7a Globule/1.3.1 PHP/5.0.5 Server at www.minix3.org Port 80
    I wanna try! ;(
  83. Fixed quote by rewt66 · · Score: 1
    What he really meant (though he may not have known it):

    "Among the people who actually design operating systems as an academic exercise or a teaching tool, the debate is essentially over. Microkernels have won."

    The people who actually design operating systems that are actually used in the real world have a different view...

  84. does he "get it"? by Cyno · · Score: 1

    The reason Linux is kicking ass today has more to do with the GPL vs. BSD than the monolithic vs. microkernel architecture debate.

    Andy's still hung up on the mono v. micro thing? Well, as long as he's not trying to compete, that's cool. Nobody tell him, let's see if he figures it out on his own..

    Sometimes I feel like our greatest minds are trapped, even lost, in time. Peer pressure and social psyche suck. If only Cannabis were abundantly legal, we'd make a lot more progress.

    But its survival of the fittest, I guess. The natural order. Harsh, but fair.

    1. Re:does he "get it"? by Eli+Gottlieb · · Score: 1

      Tanenbaum lives in the Netherlands, where said cannibis is legal.

    2. Re:does he "get it"? by Cyno · · Score: 1

      Perhaps he needs to get out more?

  85. Re:VMware image password by ezzzD55J · · Score: 1

    root, no password.

  86. Re:Why the X vs Y arguments? It's just another too by Anonymous Coward · · Score: 0

    Goddamned trackballs. I hate them.

  87. microkernel OS that doesn't suck by turgid · · Score: 1

    They have one right here.

  88. MiniX on Old Laptops, NoteBooks and PDAs by wehe · · Score: 1

    If you want to run a UniX operating system on old hardware, for example a mobile computer with 286CPU, Minix is the operating system of choice. Here are installation reports about MiniX on old laptops, notebooks and PDAs. There is also ELKS a Linux version with support for 286CPUs, but ELKS doesn't seem to be maintained anymore. Here are some installation reports about Linux on laptops and notebooks with 286CPU.

  89. LINUX is obsolete by pH7.0 · · Score: 0

    Here is the message from 1992:

    Path: sparky!uunet!mcsun!sun4nl!star.cs.vu.nl!...@cs.vu. nl
    From: a...@cs.vu.nl (Andy Tanenbaum)
    Newsgroups: comp.os.minix
    Subject: LINUX is obsolete
    Message-ID:
    Date: 29 Jan 92 12:12:50 GMT
    Sender: n...@cs.vu.nl
    Organization: Fac. Wiskunde & Informatica, Vrije Universiteit, Amsterdam
    Lines: 76

    I was in the U.S. for a couple of weeks, so I haven't commented much on
    LINUX (not that I would have said much had I been around), but for what
    it is worth, I have a couple of comments now.

    As most of you know, for me MINIX is a hobby, something that I do in the
    evening when I get bored writing books and there are no major wars,
    revolutions, or senate hearings being televised live on CNN. My real
    job is a professor and researcher in the area of operating systems.

    As a result of my occupation, I think I know a bit about where operating
    are going in the next decade or so. Two aspects stand out:

    1. MICROKERNEL VS MONOLITHIC SYSTEM
    Most older operating systems are monolithic, that is, the whole operating
    system is a single a.out file that runs in 'kernel mode.' This binary
    contains the process management, memory management, file system and the
    rest. Examples of such systems are UNIX, MS-DOS, VMS, MVS, OS/360,
    MULTICS, and many more.

    The alternative is a microkernel-based system, in which most of the OS
    runs as separate processes, mostly outside the kernel. They communicate
    by message passing. The kernel's job is to handle the message passing,
    interrupt handling, low-level process management, and possibly the I/O.
    Examples of this design are the RC4000, Amoeba, Chorus, Mach, and the
    not-yet-released Windows/NT.

    While I could go into a long story here about the relative merits of the
    two designs, suffice it to say that among the people who actually design
    operating systems, the debate is essentially over. Microkernels have won.
    The only real argument for monolithic systems was performance, and there
    is now enough evidence showing that microkernel systems can be just as
    fast as monolithic systems (e.g., Rick Rashid has published papers comparing
    Mach 3.0 to monolithic systems) that it is now all over but the shoutin`.

    MINIX is a microkernel-based system. The file system and memory management
    are separate processes, running outside the kernel. The I/O drivers are
    also separate processes (in the kernel, but only because the brain-dead
    nature of the Intel CPUs makes that difficult to do otherwise). LINUX is
    a monolithic style system. This is a giant step back into the 1970s.
    That is like taking an existing, working C program and rewriting it in
    BASIC. To me, writing a monolithic system in 1991 is a truly poor idea.

    2. PORTABILITY
    Once upon a time there was the 4004 CPU. When it grew up it became an
    8008. Then it underwent plastic surgery and became the 8080. It begat
    the 8086, which begat the 8088, which begat the 80286, which begat the
    80386, which begat the 80486, and so on unto the N-th generation. In
    the meantime, RISC chips happened, and some of them are running at over
    100 MIPS. Speeds of 200 MIPS and more are likely in the coming years.
    These things are not going to suddenly vanish. Wh

  90. If you were my student by Anonymous Coward · · Score: 0

    Disclaimer: I am the chief architect of Globule, the experimental content-distribution network used to host www.minix3.org.

    If you were my student, you wouldn't get a very high grade

  91. Can this be run from an extended partition? by The_Dougster · · Score: 1
    I'm always interested in mucking around with different operating systems, and Minix3 is no exception.

    From what I can tell, Minix requires a primary partition just like BSD's do, and I don't have any available at the moment.

    I think it would be fun to try and compile the GNU Hurd for the Minix microkernel. As long as the Minix uKernel boots on modern hardware, and has IDE, cdrom, and memory management, there's no reason why it couldn't be done in theory at least.

    The L4/Hurd crew is currently pretty cutting edge, and they are making some significant advances of late. There has been a huge surge of activity as some of the Eros developers have been making some contributions to the L4/Hurd effort.

    Be that as it may, I think it would be cool to get the Hurd running on the Minix microkernel just for fun. Of course I have no idea how to do this, but getting it installed would probably be a good first step.

    I already have GRUB installed. Does anybody know if I manage to unpack a Minix tarball onto an extended partition if it will be able to function? I'd likewise like to get NetBSD running on an extended partition. If its possible to accomplish this how about somebody replying with some good info. Don't bother to reply if you don't think it can be done. I'll assume silence equals NO.

    --
    Clickety Click ...
  92. why this is coming out now by John+Meacham · · Score: 1

    That minix is a useful low-overhead OSS operating system is incidental. the reason it exists is to provide a real base for taunenbaums books on operating systems which are greatly enhanced by the inclusion of the source code for a real working operating system. This has always been the primary goal of minix.

    The third edition of the book is coming out, hence the third release of minix is coming out in lockstep.

    http://vig.prenhall.com/catalog/academic/product/0 ,1144,0131429388,00.html

    --
    http://notanumber.net/
  93. So what OS are www.minix.org and minix3 running? by belphegore · · Score: 1

    craig@master ~ $ curl -s -I http://www.minix.org/|head -n 3 HTTP/1.1 200 OK Date: Mon, 24 Oct 2005 23:32:32 GMT Server: Apache-AdvancedExtranetServer/2.0.47 (Mandrake Linux/4mdk) mod_perl/1.99_09 Perl/v5.8.0 mod_ssl/2.0.47 OpenSSL/0.9.7b PHP/4.3.2 Interesting. craig@master ~ $ curl -s -I http://www.minix3.org/|head -n 3 HTTP/1.1 200 OK Date: Mon, 24 Oct 2005 23:33:29 GMT Server: Apache/1.3.26 (Unix) PHP/4.4.0 mod_ssl/2.8.10 OpenSSL/0.9.6c Pah! craig@master ~ $ sudo nmap -P0 -v -v -v -n -TPolite -O www.minix3.org [wait] ... Device type: general purpose Running: Linux 2.4.X|2.5.X|2.6.X OS details: Linux 2.4.18 - 2.6.11 ... I guess nobody's ported apache to minix yet...

  94. Re:So what OS are www.minix.org and minix3 running by belphegore · · Score: 1

    Well that'll teach me to "save time" by not previewing.

    craig@master ~ $ curl -s -I http://www.minix.org/|head -n 3
    HTTP/1.1 200 OK
    Date: Mon, 24 Oct 2005 23:32:32 GMT
    Server: Apache-AdvancedExtranetServer/2.0.47 (Mandrake Linux/4mdk) mod_perl/1.99_09 Perl/v5.8.0 mod_ssl/2.0.47 OpenSSL/0.9.7b PHP/4.3.2

    Interesting.

    craig@master ~ $ curl -s -I http://www.minix3.org/|head -n 3
    HTTP/1.1 200 OK
    Date: Mon, 24 Oct 2005 23:33:29 GMT
    Server: Apache/1.3.26 (Unix) PHP/4.4.0 mod_ssl/2.8.10 OpenSSL/0.9.6c

    Pah!

    craig@master ~ $ sudo nmap -P0 -v -v -v -n -TPolite -O www.minix3.org
    [wait] ...
    Device type: general purpose
    Running: Linux 2.4.X|2.5.X|2.6.X
    OS details: Linux 2.4.18 - 2.6.11 ...

    I guess nobody's ported apache to minix yet...

  95. thank you by idlake · · Score: 1

    Well, as you keep pointing out yourself, you are a typical example of a highly skilled and experienced systems programmer. Thank you for sharing your views and attitudes towards software development and application programmers with us. I think your remarks speak for themselves.

  96. Minix 3, microkernels, QNX, VM, and all that by Animats · · Score: 1
    The most useful observation about microkernels is that the commercial ones work fine, but the academic ones are lousy.

    QNX and IBM's VM are the most successful microkernel systems, with tens of thousands of installations and a user base generally happy with their performance.

    From the academic world, we have Minix, Mach, EROS, L4, and the Hurd. None of which are very successful. (MacOS X is not based on the microkernel version of Mach; it's based on an earlier version which is basically BSD.)

    It's worth reading Jorrit Herder's Minix 3 thesis. This is the guy who wrote the thing. He basically took Minix 2, yanked out all the drivers, and kept adding system calls until they could work outside the kernel. The result is on the ugly side, compared to QNX and VM. He really hasn't thought through the problems of doing device drivers in user space. The supported devices are archaic, like Centronics printers and TTY ports. In particular, no modern I/O (USB, FireWire, etc.) seems to be supported. Those are the ones where a microkernel fits well, because you have a channel driver, which talks to host hardware directly, and device drivers, which need very few privileges. But Minix isn't there yet. Actually, you'd be better off starting with the modern peripherals, especially since the OHCI and UHCI interfaces are well standardized. They also force you to think hard about how startup and shutdown should work, since you have to handle hot plugging. The design works out much better if you treat hot-plugging as the normal case and fixed peripherals as a special case of hot-plugging.

    I've written FireWire and USB device drivers for QNX. I've also written UNIX drivers. So I do know what I'm talking about here. It's really much easier under QNX in user space, and the architecture is far cleaner.

    The key to microkernel design is getting scheduling and interprocess communication absolutely right. Get scheduling order, scheduling/messaging interaction, scheduling/cache interaction, or interrupt lockout time wrong, and your microkernel will be useless. None of this shows at the API level, yet it's crucial. It's almost impossible to fix this later. It's not clear from the Minix documention how well messaging was done, or how it interacts with scheduling.

    Sadly, security seems to have been neglected. Minix 3 still has "root". It doesn't have the security functions of NSA Secure Linux, and it doesn't have an approach to messaging which deals well with security. Retrofitting security is tough and usually fails, Look at the mess in Windows. NT/2000/XP actually have a decent security system, but it's not used, because Windows 3.x/95/98/ME didn't have it, and XP had to be "compatible".

    It's a beginning. But probably too late.

    1. Re:Minix 3, microkernels, QNX, VM, and all that by The_Dougster · · Score: 1
      QNX definately rocks. Its what the Hurd wishes it could be. Basically some dudes with money completed the Hurd commercially and thats what QNX is. There's no doubt that it is a really nice OS.

      I've tried to keep an eye on QNX over the years, and its certainly a great product. I'm not sure what else I can say about it.

      --
      Clickety Click ...
    2. Re:Minix 3, microkernels, QNX, VM, and all that by be-fan · · Score: 1

      The above discussion is rather oversimplified. First, Mach isn't really an academic kernel. It was developed in rather close cooperation between the academic and commercial spaces. Moreover, it predates QNX4 by over five years, and Neutrino by more than a decade. Neutrino is really good, but its also designed with an enormous amount of hindsight about what went wrong with Mach at CMU, OSF, IBM, DEC, NeXT, etc.

      Your biggest mistake is that you say academic microkernels are "lousy", but then criticize EROS, L4, and Minix for not being successful. This indicates a deep misunderstanding of the nature of these projects. None of these microkernels are designed to compete with commercial microkernels. They are research projects, each designed to explore a particular avenue of microkernel research. EROS is designed to explore security, L4 to explore performance, and Minix is designed to be used as a teaching tool. All of these projects are successful at what they are designed to do. L4 in particular posts excellent performance figures. To say that they are not commercially successful is pointless --- they're not trying to be. You might as well criticize K42 (a commercial microkernel from IBM) for not being successful!

      --
      A deep unwavering belief is a sure sign you're missing something...
    3. Re:Minix 3, microkernels, QNX, VM, and all that by Animats · · Score: 1
      QNX definately rocks. Its what the Hurd wishes it could be.

      Very true. The Hurd debacle is sad. QNX is good, but the company behind it has backed off from their "open QNX" effort, with an accompanying decline in market share.

  97. Only one thing prevents me from trying Minix3 by Anonymous Coward · · Score: 0

    and that is lack of applications I need.

    I'll download it and try it only after it gains a robust web server, firewall & management tool (ie Shorewall, FireHOL), vim, elm, openssh, and a few more "must-haves".

    Looks very promising tho--in theory.

  98. To add to that list... by cduffy · · Score: 1

    FMI/OS (based on VSTa) is tiny, performant and arguably quite well-designed.

    1. Re:To add to that list... by naasking · · Score: 1

      FMI/OS (based on VSTa) is tiny, performant and arguably quite well-designed.

      I'm aware of VSTa. I was on the mailing list a few years ago in fact while I was still learning about operating systems. But the buffered message-passing design is a serious flaw in the system. It's not only a performance inhibitor, it also allows denial of resource attacks against the kernel. I do like it's Plan 9-semantics though; that's definitely the right/secure way to do UNIX.

    2. Re:To add to that list... by cduffy · · Score: 1

      There've been rather substantial changes since Andy Valencia was owner/maintainer.

      WRT the message passing, I'm pretty sure they don't actually *copy* the messages around anymore, but just map around who has read access to the pages containing them. [If this is what they were already doing -- oops; I'm just a userspace coder who occasionally sits in and listens to one of the core FMI/OS guys rant about what's going on that month, and I may not have been following closely enough while the recent performance-enhancing changes were being described].

      Can't comment on the DoS angle, though -- I'll have to ask about that next time I'm over that way.

  99. Better idea factory by Spiderfood · · Score: 1

    Guess what? The real contribution is in the advancement of the field. That is, the generation of new ideas! Tanenbaum is just slightly ahead here. Compare http://www.informatik.uni-trier.de/~ley/db/indices /a-tree/t/Tanenbaum:Andrew_S=.html to http://www.informatik.uni-trier.de/~ley/db/indices /a-tree/t/Torvalds:Linus.html And yes, new ideas aren't always practical--very few are actually. But new ideas are the catalyst for better ideas.

    --
    + Spiderfood
  100. minix, the little os that could by stock · · Score: 1

    minix, the little os that could. After many years Andy comes back and launches an able hobbit os :) "thank you humble coders, we bow to thee :)"

    Install it and next get his book to go with minix : http://cwx.prenhall.com/bookbind/pubbooks/tanenbau m/ "Operating Systems, Design and Implementation". After working your way through, you can call yourself a kernel/os designer/programmer.

    I think AT is a brilliant teacher. Looking inside that book : sec2.2 interprocess communication, describing race conditions, semaphores, and the classical IPC problem : The Dining Philosophers Problem. Its all very very nice explained. What about the "The Sleeping barber problem"? lol :))

    Really, and this is no kidding, this book holds the mindset of today's Linux kernel coders. Too bad that Tanenbaum got into that flamewar with Torvalds. Maybe because Linus did his monolithic thing on minix, is what made him angry. But Andy should be proud. He just happened to be around with the best book on that subject, when Torvalds started his Linux kernel in minix. That's no coincidence.

    Robert

  101. Service Temporarily Unavailable by Anonymous Coward · · Score: 0

    Service Temporarily Unavailable The server is temporarily unable to service your request due to maintenance downtime or capacity problems. Please try again later. Additionally, a 503 Service Temporarily Unavailable error was encountered while trying to use an ErrorDocument to handle the request.

  102. Small OS for small systems and Big OS for ..... by 3seas · · Score: 1

    the rest of us..

    small kernel OSs have their place and as technology makes things smaller and to some point a bit more dedicated...

    The time will come where the small kernel OSs are being used more then the big kernel Os's..

  103. Bah! Gnubies! by dbIII · · Score: 1
    The LiGnuX name some years back was a silly suggestion to describe a machine with a linux kernel, gnu tools and some form of X windows. The second attempt, which people took far more seriously was the gnu/linux thing - but after more than two seconds thought it should become clear that people outside of a project usually do not get to name it. The reality is that the entire collections get to be called by a prefix of Redhat, Debian, Slackware etc - as chosen by people that put effort into bundling a collection of software (no - a web browser is not an integral part of the OS, that was just a courtroom stunt, and neither is gcc) and not a political group formed to push an issue no matter what good things they do in other endevours.

    Does it really matter that not everyone has heard of gnu? Look back some stuff written way back when the LiGnuX debate started, and you will see that was the justification used to try to name someone else's project. Silly University staffroom politics spilled into the publicly available software world - we can move on now.