piggy

The egregious thing here is they've arrested more Jews for antisemitism which is just actually Palestinian liberation protests, and yet neonazis can just do this shit.

Mining and refining them is moreso about technological capacity

Economy of scale not technological capacity.

Essentially the problem is you have a yield of 84% iron 3% antimony for example. It only makes sense to use a nondestructive process to refine the antimony if you can make a profit on it, but with a 3% yield that is hard not only because of the small quantity, but it puts additional cost in refining out the iron later (or earlier). So sometimes you just say fuck it and only refine the iron.

The mine that the US just approved for antimony that's an ecological disaster is a gold mine that's like 2.5% antimony I think in terms of sampled yield.

Germany is the worst place ever:

https://x.com/leonidragozin/status/1895866684692709496

All Canadian energy is going to be 10%. I can only hope that in New England this is going to be the year where we regional energy conglomerate CEOs. Our prices are a cluster fuck because of inept government management (thanks "transition" fuel and "free market" energy) and the fact that our regional energy conglomerates are monopolies that have captured all regulation, to the point where they are freely admitting they haven't done proper maintenance and also that money is gone so they need to raise the rates to do maintenance. Obviously the YoY profit keeps coming.

They killed thousands of ethnic Russians in eastern Ukraine. They ran child camps teaching kids songs about killing and eating Russians, which journalists went to and got on video. They terrorized ethnic Russians, tortured and killed them and their families.

War crimes in the DNR/LNR are not the same as what you were implying. You're completely mixing shit up when it suits your argument.

Songs about killing Russians have been in Ukraine since time immemorial and have been taught to children since time immemorial. A large portion of Kolomyika songs over the last 2 centuries are about hating Russians in some way. You're entirely culturally out of your depth. For example the famous "Гуде-шумить сосоночка ", or "The Pine Trees Hum and Rustle" has the line:

Ви, москалі, людоїди, You (slur) Russians are cannibals

It was literally recorded in the USSR in 1988 for the first time and is a folk song from time immemorial. You're literally out of your depth in figuring out what is and isn't Nazi. You don't even speak any of the languages involved.

Russia effectively exports white people to Israel, they're very cozy. Russia is Israel's main supplier of oil. Which is why the Ukraine and Gaza Wars have always been funny from the perspective.

this is who they sent to fight the Ukrainian Nazis

Ukraine has a ton of Nazis in power who were specifically targeting ethnic Russians.

This is actually a farce of a point, Ukrainian Nazis aren't stupid. They don't have enough real support to go blackshirts on Russians. If this was the case the original "de-Nazification" argument would have taken a lot better and a lot quicker in Russia. Ukrainian Nazis went after extremely soft targets like Romani, Jews, and foreigners. "De-russification" has (stupidly IMO) been the most democratic policy post-Maidan. The outsized influence of Nazis in Ukraine has been because they're effective at hiding behind/within the government and popular sentiment. The reason Ukrainian Nazis are entrenched is because they get bureaucratic positions, they do absolutely terribly in the polls.

What's important to figure out is "how out in the cold are they"? Did we pull back intelligence? Are they relying on laughs Britain?

Like is the Kid Starver MI6 and Royal Airfarce supposed to be supplementing their field. The materiel is pointless without the actual intelligence. The US is essentially their lifeline to geostationary battlefield intelligence. Without that they have absolutely nothing in comparison.

Yeah too bad gns implements rate limiting and bad actor protection by essentially mimicking butt coin and requiring proof of work.

Trust is not a technologically solvable problem. This includes current DNS systems because ownership is effectively a proof of stake.

Hey buddy some of us jork it to the mDNS RFC every single day

I'm not entirely sure what you mean tbh. Like if something changes in a library you linked against? I guess you would have to rebuild it but you would have to rebuild a shared library too and place it into the system. Actually, you don't necessarily have to rebuild anything, you can actually just relink it if you still have object files around (like OpenBSD does this to relink the kernel into a random order on every boot), just swap in a different object file for what you changed

Okay let's say I am writing MyReallyCoolLibrary V1. I have a myReallyCoolFunction(). You want to use myReallyCoolFunction in your code. Regardless if your system works on API or ABI symbols, what a symbol is is a universal address for a specific functionality. So when my library is compiled it makes a S_myReallyCoolFunction, and when your app is compiled it makes a call S_myReallyCoolFunction and this symbol needs to be resolved from somewhere.

So static linking is when you compile the app with S_myReallyCoolFunction inside of it so when it sees call S_myReallyCoolFunction it finds the S_myReallyCoolFunction in the app data. Dynamic linking is when it finds call S_myReallyCoolFunction in a library that's a file on your machine. Plan9 uses static linking.

So let's talk about this what it means for "code portability". Let's say I make an MyReallyCoolLibrary V1 and I have to change a few things, here are alternate universes that can happen:

• I don't change myReallyCoolFunction
• I change myReallyCoolFunction but I do not change its behavior, I simply refactor the code to be more readable.
• I change myReallyCoolFunction and I change its behavior.
• I change myReallyCoolFunction and change it's interface.
• I remove myReallyCoolFunction.

So let's compute what this should mean for encoding a Symbol in this case.

• myReallyCoolFunction from V2 can stay declared as S_myReallyCoolFunction
• myReallyCoolFunction from V2 can stay declared as S_myReallyCoolFunction
• myReallyCoolFunction from V2 has to be declared as S_myReallyCoolFunctionNew
• myReallyCoolFunction from V2 has to be declared as S_myReallyCoolFunctionNew
• I technically no longer have an S_myReallyCoolFunction

Now these are the practical consequences for your code:

• none, everything stays the same and code written to V1 can use V2.
• none, everything stays the same and code written to V1 can use V2.
• app refactor - everything written for V1 has to change to use V2. The app may no longer be able to work with V2.
• app refactor - everything written for V1 has to change to use V2.The app may no longer be able to work with V2.
• app refactor - everything written for V1 has to change to use V2.The app may no longer be able to work with V2.

So now to make code truly portable I must now remove the app refactor pieces. I have 2 ways of doing that.

1. Version resolution from inside the system by managing lib paths most likely.
2. V2 must include all symbols from V1

With #1 you have the problem everyone complains about today.

With #2 you essentially carry forward all work ever done. Every mistake, every refactor, every public API that's ever been written and it's behaviors must be frozen in amber and reshipped in the next version.

There is no magic here, it's a simple but difficult to manage diagram.

Plan 9 is a carefully tuned system ofc and I obviously have the Plan 9 brainworms but like.....

I agree that Plan 9 is really cool, but in practice Linux is the height of active development OS complexity that our society is able to build right now. Windows in comparison is ossifying, and OSX is much simpler.

I've never written any programs that were subject to such strict verification tbh. I had to look up what "DSL" means lol, Wikipedia says "definitive software library".

DSL in this case means Domain Specific Language

I rly think it's not such a problem most of the time, code changes all the time and people update it, as they should imo,

But here's the problem with this statement, it unravels your definition of "code portability". The whole point of "code portability" is that I don't have to update my code. So I'm kind-of confused about what we're arguing if it's not Flatpak style portability, it's not code portability, what are we specifically talking about?

And that formal verification can only get you as far as verifying there are no bugs but it can't force you to write good systems or specifications and can't help you if there are things like cosmic rays striking your processor ofc hehe

The formal verification can only reify the fact that you need something called Foo and I can provide it. The more formal it is the more accurate we can make the description of what Foo is and the more accurately I can provide something that matches that. But I can't make it so that your Foo is actually a Bar because you meant a Bar but you didn't know you needed a Bar. We can match shapes to holes but we cannot imbue the shapes or the holes with meaning and match on that. We can only match geometrically, that is to say (discrete) mathematically.

I agreee, this isn't just a technological problem to me but also a social one. Like ideally I would love to see way more money or resources for computer systems research and state-sponsored computer systems. Tbh I feel like most of the reason ppl focus so much on unchanging software, ABIs, APIs, instruction sets, operating systems, etc is cuz capitalists use them to make products and them never changing and just being updated forever is labor reducing lol. When software is designed badly or the world has changed and software no longer suits the world we live in (many such cases), we (the community of computer-touchers lol) should be able to change it. Ofc there will be a transition process for anything and this is quite vague but yeh

I generally agree with this sentiment but I think the capitalist thing defeating better computing standards, tooling, and functionality is the commodity form. The commodity form and its practical uses don't care about our nerd shit. The commodity form barely cares to fulfill the functional need it's reified form (e.g. an apple) provides. That is to say, the commodity form doesn't care if you make Shitty Apples or Good Apples as long as you can sell Apples. That applies to software, and as software grows more complex, capitalism tends to produce shitty software simply because the purpose of the commodity form is to facilitate trade not to be correct/reliable/be of any quality.

You just link against the symbols you use though :/ Lemme go statically link some GTK thing I have lying around and see what the binary size is cuz the entire GTK/GLib/GNOME thing is one of the worst examples of massive overcomplication on modern Unix lol

If you link against symbols you are not creating something portable. In order for it to be portable the lib cannot ever change symbols. That's a constraint you can practically only work with if you have low code movement and you control the whole system. (see below for another way but it's more complex rather than less complex).

Also I'm not a brother :|

My bad. I apologize. I am being inconsiderate in my haste to reply.

It was less complex cuz they made it that way though, we can too. FlatPaks are like the worst example too cuz they're like dynamically linked things that bring along all the libraries they need to use anyway (unless they started keeping track of those?) so you get the worst of both static and dynamic linking. I just don't use them lol

But there's no other realistic way.

You mean portable like being able to copy binaries between systems? Cuz back in the 90s you would usually just build whatever it was from source if it wasn't in your OS or buy a CD or smth from a vendor for your specific setup. Portable to me just means like that programs can be be built from source and run on other operating systems and isn't too closely attached to wherever it was first created. Being able to copy binaries between systems isn't something worth pursuing imo (breaking userspace is actually cool and good :3, that stable ABI shit has meant Linux keeps around so much ancient legacy code or gets stuck with badddd APIs for the rest of time or until someone writes some awful emulation layer lol)

That's a completely different usage of "portable" and is basically a non-problem in the modern era, as long as and see my response to the symbols point, you are within the same-ish compatibility time frame.

It's entirely impossible to do this over a distributed ecosystem over the long term. You need symbol migrations so that if I compile code from 1995 it can upgrade to the correct representation in modern symbols. I've built such dependency management systems for making evergreen data in DSLs. Mistakes, deprecation, and essentially everything you have ever written has to be permanent, it's not a simple way to program. It can only be realized in tightly and directly controlled environments like Plan 9 or if you're the architect of an org.

Dependency management is an organization problem that is complex, temporal, and intricate. You cannot "technology" your way out of the need to manage the essential complexity here.