Pair-instability can only happen in low-metalicity surroundings.
The big bang created hydrogen, helium, and small amounts of lithium. Any higher elements are created by stars, and a significant presence of those "metals" will take a star down a different path than pair-instability.
Low-metalicity environments are not likely to be friendly to life.
> Cell sizes are not fixed, however, even within a single species. Cells often swell as they increase their production of proteins and metabolites in preparation for division. This is in line with biology’s only rule: namely, there are exceptions to every rule!
> Case in point: a giant bacterium called Thiomargarita magnifica can extend about one centimeter in length, so large that it can be seen by the naked eye. It does so by breaking the surface area-to-volume rule, filling between 65–80 percent of its internal volume with an empty vacuole. In other words, it pushes most of its molecules to the cell periphery, thus shortening diffusion distances.
There is also a captioned image of bubble algae in the post.
Collected and stored sediment samples were found to have surviving T. namibiensis cells after over two years. The cells had no access to any added sulfide or nitrate during this time. In the surviving cells, there was a notable size decrease. To survive without growing the cells depended on the nutrient stores of the central vacuoles.
Indeed. It says they rely on two different substances which normally don't mix (nitrates and sulfites), presumably because if they were both present at the same time they'd react with each other directly without the bacterium extracting any energy from that. So they live in places that sometimes have one and sometimes the other, and have to store one of them until the other comes along, which can be years. Or that's how I read it.
Agreed. Humans draw rather arbitrary distinctions. It was quite funny in regards to viruses, aka parasite. Mimivirus are still a parasite, of course, but they even encode genes for metabolic pathways and are larger than some bacteria.
See:
"The Mimivirus is a giant virus that infects amoebae and was long considered to be a bacterium due to its size."
Although for me, I always used the definitions through the genetic information available (genome). So as long as a virus still is a parasite, I'd hold up that definition. It will be interesting when viruses are found that are even closer to a cell, e. g. some life cycle where they could switch between parasitism and stand-alone metabolism (or some hybrid in between; I mean if they can encode whole metabolic pathways, at the least some or some parts of it, the threshold here should not be impossible to overcome, and then the whole definition of a virus also has to be adapted since it would no longer make sense).
These both feature large central vacuoles, lending support the thesis of the article that the cubic growth in volume outstrips the quadratic increase in surface area for transferring nutrients and waste across the cell membrane.
Those still seem kind of small? Why not the size of an mature olive tree for example? I'm guessing the article may answer this, haven't gotten that far yet.
Granted, they are grouped both in Thiomargarita. 2cm is pretty gigantic. What I always found more interesting was that they don't merely have just one genome.
Actually, there is a native fork. There had to be, as POSIX personality support was a part of the Windows NT 3.1 design. What there wasn't was a Win32 form of fork. The Native API for Windows NT allowed it quite straightforwardly.
"UTF-16 is used by the Windows API, and by many programming environments such as Java and Qt. The variable-length character of UTF-16, combined with the fact that most characters are not variable-length (so variable length is rarely tested), has led to many bugs in software, including in Windows itself.
"UTF-16 is the only encoding (still) allowed on the web that is incompatible with 8-bit ASCII. It has never gained popularity on the web, where it is declared by under 0.004% of public web pages (and even then, the web pages are most likely also using UTF-8). UTF-8, by comparison, gained dominance years ago and accounted for 99% of all web pages by 2025."
NT shipped with USC-2 as UTF-8 (and -16) did not yet exist. USC-2 naturally translated to UTF-16, hence the choice. NT/Win32 is also designed for fixed-with code units, something UTF-8 doesn't support.
You can use UTF-8 on a per-application basis, within limits.
Linux kernel's ABI/API surface is completely byte-based and is tiny compared to Win32 API. The stable ABI of Windows is strictly in the user space and it covers the entire useful operating system. Don't forget that glibc isn't that ABI stable nor anything that goes all the way up to systemd/X11/gettext/Wayland/cairo/GTK/Qt/glade/Pipewire/xdg. Nothing equivalent in Linux environment is stable, especially compared against Win32 system libraries.
You encounter encoding requirements not in kernel system calls but in more user-facing sides of the OS. So your comparison should include all the userspace components of a Linux system (e.g. gettext), if you're considering the places where you encounter actual Unicode string-based operations where UTF-16 comes into play in Windows.
ALL OF THE equivalent Windows libraries (user32.dll, kernel32.dll, ws2_32.dll, shellex.dll ...) to the Linux ones I counted above and more are ABI and API stable.
Additional Detail: it is specifically utf-16 little endian when a byte order mark is not used, which is the opposite of the recommended choice of big endian in the RFC.
Worse are the byte order marks required to support both endians that end up in files.
The development of Windows NT based on UCS-2 precedes the RFC by roughly a decade, and little-endian was the natural choice for the Intel PC platform. Obviously the endianness had to remain the same when UCS-2 was extended to support UTF-16.
UTF-16 is also used by C#, Java, and JavaScript. Since JavaScript is so widely adopted, I wouldn't call it a rare bird. Not necessarily used when reading or writing files, but it's what's used internally for the strings. As a result, your strings use UTF-16 surrogate pairs to represent characters outside of the basic multilingual plane (such as Emoji).
UTF-16 is the internal format of the ICU library (International Components for Unicode, the support library from the Unicode standards people) which is a common way to add "full fat" Unicode support to a programming language. This has knock-on effects everywhere. If you're using ICU, you either use UTF-16, too, or you constantly convert back and forth every time you interact with ICU. You're often best off using UTF-16 in memory and only converting to UTF-8 when you write files or transmit over the network.
an interesting tidbit, some Windows kernel developer realized that most registry keys are ascii anyways so they could save up to 50% space simply by storing the name as ascii. The flag is called "compressed name" and they will pad with 0x00 when reading the name to make a proper utf-16 string.
I was going to comment that any sort of script that you are using in multiple environments probably should have all of the paths completely written out. I usually try to do this myself as I have gotten burned by binaries from unexpected paths on new systems a number of times.
But then I realized that the point of this project is to make it easy to write scripts that can be used on multiple OSs... and that is going to make fully-qualified paths possibly a nightmare. Anyone know if these get put at `/bin/`?
A big part of the point is so you can use scripts made for other platforms on windows natively, which you lose when you have to alter them to pass absolute paths
Busybox helps you avoid this nicely on Windows. When you run one of one of its shells, it uses all it's own builtins in preference to anything external.
Get the 64-bit version: "there's some advantage in using the 64-bit executable busybox64.exe. In particular, it can be quite a bit faster."
Busybox is nice, but it's kind of like the Blender default cube to me: my only memories of it are removing it on sight to replace with something better.
It actually failed even before that. The project states "The goal is to make moving between Linux, macOS, WSL, containers, and Windows frictionless: the same commands, flags, and pipelines work the same way, so *existing scripts carry over without translation.*"
... but they failed to provide a port of Bash - so how exactly do they expect someone to run a bash script in Windows "without translation"? If the answer is WSL, then there's no need to port the coreutils over because WSL distros already include them. If the answer is to port the scripts over to PowerShell, then you wouldn't want to call Windows coreutils in your PowerShell scripts and run into unexpected behaviour (and also lose out on the object manipulation advantages of PowerShell).
And finally, they failed to port over commands that would actually be useful - like dd, for writing ISOs to a flash drive or backing up drives. chroot could've taken advantage of Windows' new sandbox feature to switch to a virtual C: drive. chown could've been an easier alternative to takeown/icacls. chmod could be used to remove the annoying network file blocks and also change file attributes and so on.
This whole project seems like a half-assed attempt at nothing.
Maybe someone out there mixmashes PowerShell, bash, sh and cmd scripts from different platforms in one session - but usually it's one, quite straightforward 'flow' which requires a quite specific environment.
The big bang created hydrogen, helium, and small amounts of lithium. Any higher elements are created by stars, and a significant presence of those "metals" will take a star down a different path than pair-instability.
Low-metalicity environments are not likely to be friendly to life.
reply