Similarly the FDs to open files give you organized access to space on
a disk drive, and you can always open the partition device and manage
the storage yourself.
Similarly, only root can have direct access to the raw device. Otherwise,
any user would be able to read any other user’s files, modify any file at
whim, totally corrupt the filesystem etc.
Of course, using UDP is not the same as implementing your own TCP
stack. You just do not need the enormous amounts of sockets even if
you communicate with multiple hosts. And you have to keep track of the
communication yourself because the OS will not do it for you.
Also you would want to decide for each partition if you use it for a
filesystem and mount it, or give access to the partition to a service
or user. Note that mtools use raw floppy devices in exactly this way,
and given the access they can be used for partitions as well.
The throughput of the structured IO would be usually lower because the
I really should let this go because it has nothing much to do with Ruby, but
Note that accessing the partition and bypassing the filesystem layer
you still use the optimized and balanced drivers. But you do not get
the benefit of organizing your data in the hierarchical namespace the
filesystem provides.
The fact that half of an unix-like system resides in the kernel causes
problems like this. Only filesystems compiled into the kernel can be
mounted. Only root can mount filesystems. Opening too many files is
not allowed because it drains kernel resources. Etc, etc.
Certainly many things have stood the test of time but doubts exist
about their optimal design. For one, the QWERTY layout was designed
for mechanical typewrites that suffered from collisions of the
mechanical parts. It was optimized so that such collisions are
unlikely. Since then new layouts emerged that were optimized for
typing speed. But QWEERTY has stood the test of time, much longer than
UNIX
