For those of you who are new to Linux, I know you probably know about the cpus. But for those of you who have been using the kernel as your primary operating system for years, you are probably wondering: Why would you ever want to use more than one CPU, and why would you want to do this all the time? Well, that is a good question that I have been pondering lately.
This is another kind of question I have, but it’s a good one. If you’re a Linux fan, you might be a bit of a hard-worker. You can’t really use a lot of programs and have to deal with them all. When you have other people do stuff like this, they will have to deal with it, and many of them will have to deal with it.
As you might imagine, this is a common problem for Linux kernel developers. And it’s also a problem that is compounded with the many different hardware architectures out there. Most hardware manufacturers (and companies) want their proprietary (closed-source) kernels to run on their hardware as well, but some hardware vendors use open-source kernels instead (which are the default now).
Which is exactly why Linux kernel developers have been having these issues for a long time: the kernel is a complex piece of software. It’s a collection of many different parts. There is a kernel code base for building the hardware (i.e. making it work), there are kernel drivers and so on and so forth. You can’t build a new kernel from scratch without rebuilding all of them.
The problem is that these kernel developer groups are all very tight-knit. They usually meet up once a week to discuss their work and usually talk about their latest patches. But when they aren’t talking about their latest work, they are discussing which CPUs they are going to build on.
The reason why most kernel developers are so tight-knit is because they need to be working on the kernels in order to help the people who make the hardware. This means that the only way to know what is going to happen with your CPU is if you and your coworkers are actually talking about it, but these kernel developer groups talk a lot about their work and they are usually pretty open in their discussions.
As an aside, they are often wrong about being able to build on the CPUs. As a result, I think there are a few people who do not need CPUs, but they do need to be able to build on them.
The kernel developers are a bunch of angry people who can not be trusted with anything important. They are not the ones who build on the CPUs and end up having a bug in their code that will cause them to lose data. The people who write the code that builds on the CPUs are the ones who are actually using the data that is supposed to be there. If a developer complains about someone in the project, it’s usually because they are complaining about something that they didn’t do.
The difference between a new kernel and a static one is that the static kernel is a bit more complex in that it starts out on the computer with a different memory address but an initial address is what’s needed. In the new kernel, the address changes from the initial one to “mmap”.
