There are a lot of debates on this subject. Because I have a fetish for explaining things I'll try to detail the field.
There aren't a lot of solid definitions of a kernel, but the usual bare-bones definition is, it must handle interrupts (signals to the processor, like power-on, etc), synchronize the processor with other applications, aka multitask, and manage memory. It's what controls all of the computer's resources and what allows applications to run, essentially. Older operating systems and MS-DOS don't do multitasking but I'm just giving the definition of a modern kernel. In other words, the kernel
is the operating system, the core part of it (which is why it's called a "kernel").
Kernels are usually divided into Kernelmode and Usermode. When software runs in Kernelmode, it has access to the entire computer and nothing really restrains it, usually what runs in Kernelmode is the kernel itself and maybe some system-critical services. Usermode is where most applications run, they can't do anything without asking the OS if it's okay to do it first, and they can't see the memory of other applications. They're entirely isolated, except for talking directly with the OS.
Monolithic kernels do not only do what a kernel has to, but have a lot more software within the kernel itself. Things like drivers, the display stack and system services. This is considered faster to do, because rather than having some time-critical software like drivers and display stacks go through the OS to do anything, they can just do it. The downside is, if anything crashes in the kernel, and a lot of stuff is inside a monolithic kernel, then the entire OS will crash.
Microkernels
only do what a kernel has to. Device drivers and system-critical services are kept out of the kernel, and only run in Usermode. If they crash, nothing bad happens. The kernel, if set up to do it, can automatically revive the fallen process and continue working normally. Minix 3 does this,
Andy Tanenbaum shows it off.
Windows NT is actually a bit of a fractured case. It has a genuine Microkernel. In fact, the memory manager isn't even in the kernel, it's a separate process. However, it runs a lot of system-critical processes in Kernelmode. It's considered a Hyrbid Kernel for that reason. Device drivers used to be in Kernelmode, but NT gradually began to support drivers in Usermode, and now modern Windows has mostly Usermode drivers.
Linux is a genuine Monolithic kernel. Essentially, absolutely everything is in the kernel. That, combined with it's horrible drivers, causes it to crash quite a lot, unless you just get lucky.
This is a good thread on the Haiku forums criticizing Linus' deranged vendetta with Microkernels, might be insightful for you.
Also, as a side note, Linux isn't an operating system, it is in fact a kernel. Linux can't run by itself. Well, it can, but, you can't do anything with it. That's why some people call it GNU/Linux, because the GNU userland and coreutils provide tools that talk to the kernel which allow you to actually use it. Though, Busybox is also a set of coreutils that can replace GNU's, and I've never heard anyone say "Busybox/Linux". Probably why people mostly call the entire OS just "Linux". Other OSes provide their own kernel and coreutils, so they have full right to call their complete OS whatever they want (e.g. FreeBSD has their own kernel and userland, so the whole thing is just called FreeBSD and not any other name).
Really, the only people who think Monolithic kernels are "better" is Linus Torvalds himself. They're unreliable by nature, but some people desire them because they run a picosecond faster, so they think it's worth abandoning absolutely all safety and security measures for that tiny bit of speed you can't even notice on modern processors. Microkernels can heal themselves, when a driver crashes, most of the time it can bring them back up like nothing happened. I remember one time I was using Windows 7 and my display driver crashed. The screen went black for a second, then Windows automatically restarted the driver and everything was how it should be. Linux cannot do this, the driver crashing would crash the entire system, and that's happened to me too.
I'm a huge fan of pure Microkernels, but I think Windows NT hit a good balance. Most of the stuff running in Kernelmode would cause the OS to stop working if they crashed anyway. Heck, a lot of stuff running in Kernelmode would normally be part of the kernel itself, like the memory manager. So it's really not a huge deal. I usually refer to Windows as a Microkernel, even if it is a Hybrid. I especially sometimes call it a Microkernel because other "Hyrbid" OSes like OS X and Haiku really are more along the lines of just really small Monolithic kernels, NT is far more complex than those and I don't think it deserves to be categorized with them.
ReactOS' kernel is a clone of NT's kernel (Server 2003), written from scratch. It has the exact same architecture (well almost, it's still a work-in-progress but that's the ultimate goal).
the Architecture of Windows NT Wikipedia article is really a good read about what runs in Kernlemode. Another good read is the
NT boot process.[/quote]
thnk you very much @konata for sharing me this information but after debate w/ a programmer from a guy on the other forums i came to realize that linux can be just as stable windows as long as there is a massive resources and developers on working on it 24/7 just like windows which lead to conclusion that OSX is just as stable as windows