This Is Why They Say ...
... Windows is a great OS — if your time is worth nothing.
899 publicly visible posts • joined 21 Dec 2023
that can take criticism from others without reacting like it’s been picked on. It doesn’t respond with hostility to reports from human-rights organizations. It doesn’t hate the UN and try to sabotage its operations. It abides by international law, and accepts legally-binding directives from bodies like the Security Council and World Court.
In short, it’s a regular part of the world community, like most nations.
It’s funny, isn’t it: Israel prides itself on not being like the others: it’s the only “democracy” etc. Yet when you point out things it is doing wrong, that instantly triggers the “what about the others” reactions. It’s basically an admission that, deep down, it is not so different from those others, after all.
In that case, why can’t you perform container-style isolation, running multiple alternate userlands, on Plan 9? That’s the kind of thing that is easily done on Linux.
Think of it the other way round: Plan 9 “namespaces” are equivalent to just “filesystem namespaces” on Linux. Linux puts all its other userland-accessible kernel facilities into their own namespaces as well: processes, user IDs, network interfaces, even the host name and system time. In addition, it has “cgroups” for managing groupings of processes and controlling their resource usage. “Containers” are not a primitive provided by the Linux kernel, but are woven out of all these lower-level bits. This is why you have a range of container styles, from basic things like systemd-nspawn and LXC all the way up to Docker and beyond.
In short, Linux has no need to suffer from namespace-envy: Plan 9 is the one suffering from container-envy.
“Linux is a dead end too. Unix in general is. We should have gone with Plan 9, and we still should.”
— Liam Proven, back on 12th April.
Back in the day, some were fans of the Z80, while others swore by the 6502. The latter pointed to how their favourite chip could do so many things in a single clock cycle, that the Z80 took several cycles to match.
What they neglected to mention was that the 6502 was doing these single-cycle operations on strictly 8-bit quantities, where the Z80 was trying to support full 16-bit arithmetic in all its addressing. For example, the 6502 was limited to a 256-byte stack that had to reside in page 1, while the Z80 had a full 16-bit stack pointer, the same size as all its other address registers.
... to run Windows NT on it.
By about the mid 1990s, there were four main OSes available for the Alpha: DEC’s own OpenVMS and “OSF/1” (later to be renamed “Tru64”) Unix, Mirosoft’s Windows NT, and this newfangled “Linux” thing.
Remember, the Alpha was a full 64-bit architecture, back when that was still a novelty. Both Unix and Linux were full 64-bit. VMS on Alpha was a hybrid 32/64-bit OS. While Windows NT ran strictly in 32-bit “TASO” mode (“Truncated Address Space Option”), pretending that the top 32 bits of each address simply didn’t exist.
See what I mean about a waste?
Ever since the first computer “viruses” and “worms”, the parallels with actual biological phenomena, initially seen by many as just spurious analogies, have only grown more eerily accurate. Now we see that equipping computers with immune systems can be just as much a double-edged sword as our own bodies’ defences against pathogens: liable to attack that which they are supposed to be protecting.
Biological evolution is blind, undirected and unplanned, but human intelligence need not be. Instead of merely recapping existing biological processes, we should be able to go beyond them.
Two answers.
1) These complicated trajectories tend to take a long time to get where you want to go, at the speed you want to be going at. For example, look at those comet rendezvous missions involving sling-shotting off the inner planets multiple times, taking several years in the process.
2) Tell that to the quantum computing folks. If an O(n) increase in processing elements is supposed to give you an O(e**n) increase in processing power, and that’s not some kind of “something for nothing”, then I don’t know what it is.
The reality is, on-prem Windows Server is no longer where the big bucks are for Microsoft. Yup, their emphasis is very much on the cloud.
Want Windows-Server-type functionality under your own control? Use the same open-source pieces Microsoft itself copied, namely Kerberos and LDAP, combined with Samba, running on a Linux box. And there you have something that no Microsoft or any other BigCorp™ can ever take away from you.
Actually, no. Notice in the description of the indentation rule, in Python 3.1 you have the statement “Indentation is rejected as inconsistent if a source file mixes tabs and spaces in a way that makes the meaning dependent on the worth of a tab in spaces; a TabError
is raised in that case.” This rule is not present in Python 3.0.
So it was introduced in Python 3.1.
My way:
(defun set_tab_expansion (expand)
␣␣␣␣"changes tab expansion setting for current buffer."
␣␣␣␣(interactive)
␣␣␣␣(cond
␣␣␣␣␣␣␣␣(expand
␣␣␣␣␣␣␣␣␣␣␣␣(setq indent-tabs-mode nil)
␣␣␣␣␣␣␣␣␣␣␣␣(message "tabs will be expanded to spaces")
␣␣␣␣␣␣␣␣)
␣␣␣␣␣␣␣␣(t
␣␣␣␣␣␣␣␣␣␣␣␣(setq indent-tabs-mode t)
␣␣␣␣␣␣␣␣␣␣␣␣(message "tabs will not be expanded to spaces")
␣␣␣␣␣␣␣␣)
␣␣␣␣) ; cond
) ; set_tab_expansion
Tab stops were always like that. They were always meant to represent configurable positions on the typewriter, printer or display screen. Computer printers even had vertical tab stop settings. (And that’s why ASCII has both “HT” and “VT” control characters.)
You see why it’s a good idea to avoid tabs for formatting?
Assuming you can control the rules they use, rather than have them impose their own rules on you.
For another example of my style:
LIBNAME = \
␣␣␣␣{
␣␣␣␣␣␣␣␣"linux" :
␣␣␣␣␣␣␣␣␣␣␣␣{
␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"cairo" : "libcairo.so.2",
␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"freetype" : "libfreetype.so.6",
␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"fontconfig" : "libfontconfig.so.1",
␣␣␣␣␣␣␣␣␣␣␣␣},
␣␣␣␣␣␣␣␣"openbsd6" :
␣␣␣␣␣␣␣␣␣␣␣␣{
␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"cairo" : "libcairo.so.12",
␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"freetype" : "libfreetype.so.28",
␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"fontconfig" : "libfontconfig.so.11",
␣␣␣␣␣␣␣␣␣␣␣␣},
␣␣␣␣}[sys.platform]
I used to use tabs, back in the day, but with the meaning that tab stops were positioned every four columns, not eight. Eight never made any sense to me (some old typewriter convention or something), and still doesn’t.
But I gave up and switched to spaces maybe a couple decades ago. But for compatibility, I still have my editor configured to take a quick sniff of every file I open: if it spots a tab, then it configures the tab key to emit literal tabs. Otherwise, pressing tab inserts some suitable number of spaces.
Newer versions of Python (from 3.0 if I recall rightly) are stricter: successive lines which are supposed to have the same indentation now have to begin with exactly the same sequence of whitespace. You can’t put a tab on one line and a space in its place on another. This avoids a lot of common mistakes.
I decided early on in my Python code to add “#end
” comments to mark the ends of compound statements. I also have custom editor commands defined to jump between lines with matching indentation. This makes it easier to ensure that things are properly nested.
A (small) example:
def set_wakeup_main_function(self, wakeup_main, data, free_data = None) :
␣␣␣␣"sets the callback to use for libdbus to notify you that something has" \
␣␣␣␣" happened requiring processing on the Connection."
␣
␣␣␣␣def wrap_wakeup_main(_data) :
␣␣␣␣␣␣␣␣wakeup_main(data)
␣␣␣␣#end wrap_wakeup_main
␣
␣␣␣␣def wrap_free_data(_data) :
␣␣␣␣␣␣␣␣free_data(data)
␣␣␣␣#end wrap_free_data
␣
#begin set_wakeup_main_function
␣␣␣␣if wakeup_main != None :
␣␣␣␣␣␣␣␣self._wakeup_main = DBUS.WakeupMainFunction(wrap_wakeup_main)
␣␣␣␣else :
␣␣␣␣␣␣␣␣self._wakeup_main = None
␣␣␣␣#end if
␣␣␣␣if free_data != None :
␣␣␣␣␣␣␣␣self._free_wakeup_main_data = DBUS.FreeFunction(wrap_free_data)
␣␣␣␣else :
␣␣␣␣␣␣␣␣self._free_wakeup_main_data = None
␣␣␣␣#end if
␣␣␣␣dbus.dbus_connection_set_wakeup_main_function(self._dbobj, self._wakeup_main, None, self._free_wakeup_main_data)
#end set_wakeup_main_function
There’s the simple fact that you can dual-boot multiple Linux distros, and have them share the same /home
area. So you can easily “distro-hop” without having to keep copying all your user files from one installation to another.
There’s the fact that you can run the userland for one distro as a container with another as host.
And yes, Linux distros can be as different as chalk and cheese. Compare, say, Gentoo or Arch with Android, or something as completely off-the-wall as GoboLinux. Look at this idea of “immutable” distros. Look at “toolkit” distros like Kali or SystemRescue. The BSDs have nothing like that.
And what makes them all “Linux” is they share the same kernel.
There are maybe half a dozen current BSD variants still in some stage of active development, versus maybe 50× that number of Linux distros. Yet it is easier to move among Linux distros than it is to move among BSD variants.
Linux offers a greater degree of variety with less fragmentation, while the BSDs seem to be more about greater fragmentation and less actual variety.
NetBSD seems to count every single variation of a processor platform (e.g. Amiga PowerPC versus Mac PowerPC) as a separate “architecture”, whereas Linux counts them all as one.
So this idea that “there's no other OS in the world that runs on so many different architectures and platforms” seems a bit suspect to me: just name one platform where NetBSD runs, but Linux doesn’t.
Of course you’ll get used to it. Just like all the other indignities enrichments of the user experience that Microsoft has inflicted innovated on you. After all, you’re still using Windows, aren’t you? And admit it: for all your grumbling, that isn’t really going to change, is it?
No, just on their own—namely, “the huge number of corporates addicted to exchange”. Those with a legitimate (?) need to send out bulk emails will either move away from Exchange, or learn to live within its limits.
Either way, the problem solves itself.
This is why Open Source is all about choice.
After I noticed this starting to happen, I developed the habit of waiting 30-60 seconds, then opening the link to my comment in a private-browsing window. If I could still see it, then that meant it hadn’t been deleted.
If my comment was deleted, then I might try to narrow down the cause of the deletion: split the comment in half, and see if the first half gets through. Sometimes it’s a particular trigger word, which I could get around by splitting the offending word in half.
Sometimes the simple act of splitting the comment up was enough to bypass the filter.
Somehow, I don’t think this is true any more. Office 365 may still be a major cash cow, but it’s clear that Windows itself is no longer quite as profitable as it once was. You see this in the declining level of investment put back into the OS, as evidenced by the deteriorating quality of software releases, and even of patches to fix the problems in those releases.
If Microsoft were a rational business, out to exploit business opportunities wherever they may be found, it would offer 365 online services for LibreOffice.
Well, it doesn’t have the “Ribbon”, if that’s what you mean.
Remember, the Office 365 Ribbon was created in the days before modern widescreen monitors became popular. But most text documents that people create are still in portrait format. So some large GUI megawidget chewing up a substantial portion of the height of your screen reduces the amount of your document you can see at once, while wasting space on the sides.
That’s why LibreOffice has the Sidebar instead. So you have more of the height of your screen available to show more of your document.
It may not look like it, but that’s the task_struct for pid 1. You will notice there is no fork
call anywhere in there. The execution of the specified command for the init process happens in init/main.c, where it is done via run_init_process
, which in turn uses kernel_execve
, which is just the in-kernel entry point for the execve
system call.
Since there is no creation of a new process, that means it must be running in the already-created process context, which is that init_task
.
So you see, there is no such process as “pid 0”.
You see the type in the comments sections on this very site, don’t you? Those who love to pontificate about how Open Source doesn’t quite suit their needs. When it is pointed out that the code doesn’t write itself, that it all happens because somebody cared sufficiently to get off their bum and actually do something about it, the response is either bluster or silence.
Torvalds was right to call their bluff.
You realize it’s your choice to run a Linux distro with (or without) systemd, right?
VMS clusters were far more limited than you seem to think. You don’t have to take my word for it: go read the docs for yourself, at Bitsavers and elsewhere.
DEC created its original VAXcluster concept back when other vendors were offering proper file servers. Instead of doing the same, it created a shared disk controller, with the same filesystem mounted in parallel across multiple nodes. To avoid stepping on each others’ toes, the nodes communicated via a protocol called SCS, which implemented distributed locking. What made things simpler was there was no data caching going on at the time.
Note that none of the other usual VMS IPC mechanisms—mailboxes, shared memory, common event flags—worked clusterwide. In no sense did a cluster look like one big machine. Looking at processes and terminals and other devices on one machine did not show you those on other machines. They were still very much separate machines. Even doing remote admin between them required a separate DECnet connection!
About ten years later, the next big innovation was the addition of clusterwide logical name tables.
And that was it. That was the sum total of what VMS clusters did for you. And, like I said, it never scaled beyond the maximum number of nodes you could attach to the same shared disk controller.
It was Linux that offered the choice of tight or loose clustering, not VMS.
And yes, UNIX became popular on its own merits. There was no big corporation pushing it: remember, it came from AT&T, which didn’t even have a presence in the computer market. It was the customers who forced the vendors into adopting it.
“We should have gone with Plan 9” ... nothing’s stopping you from joining that “we”. Go on, try making it your daily driver for a few months, and let us know how you go.