LucifarGundam @lucifargundam@qoto.org

Testing connecting the worst imaginable wireless aftermarket controller to the #Xbox bouncing it via #Android. I’m testing to see if this is viable given Microsoft is banning unlicensed wireless controllers, but there’s perceptible lag (the controller is a pile of poo! That’s also a problem). I could tinker with the router to prioritise traffic to and from the Android phone in question, if I recall right I deprioritised everyone’s phones. #gaming

You slept soundly through the night, regaining 16 hitpoints and 2 hitdice.
---
You are safe in a small village, what would you like to do?

#X #Twitter #FAIL #СкриншотыКаментов #ВеселыеКартинки

If you used the internet in the US in the early 90s, your traffic was handled by Trans Witches! (A TRANSWITCH chip was part of every interface board on the NSFnet's experimental T3 routers.)

https://www.rcsri.org/collection/nsfnet-t3/

#Halloween #Witches #Internet

@PeterCxy@comfy.social Fundamentally there's an inherent contradiction between "C as high-level assembly" (but at the expense of portability and optimizations) and "C as a high-level and portable programming language" (but at the expense literal translation to machine code). C attempts to be both. It was historically first used by Unix hackers as a form of high-level assembly, and later another group joined with people who use C as a general-purpose high-level language. This started all the troubles.

K&R C (pre-ANSI) did not have a formal logical specification. The expected behaviors were simply "whatever side-effects that the actual machine code creates after compiling". It was designed not by theoretical CS researchers but by Unix kernel hackers as a minimum-viable high-level language, with line-by-line literal translation to machine code in mind. The original Unix code made liberal (ab)uses of PDP 11-specific behaviors, and in early versions, even compiler-specific ones ("you're not expected to understand this" was a hack based on the compiler's register allocation).

Inevitably, when different platforms are targeted, the side-effects are going to be different. To be portable, the idea is to use a restrictive subset of K&R C operations that absolutely does not depend on platform behaviors (which would later be codified as the ANSI C's abstract machine). To complicate the problem further, compiler writers also want to do high-level reasoning for optimization and vectorization that would be impossible if unexpected side-effects exist - but the original C was never designed to do that. The result is that only a heavily restricted subset of possible operations in C is "proper C", leaving the rest as undefined or implementation-defined (in practice, with the tendency of getting more and more restrictive over time as optimizer becomes more aggressive over time) - sometimes unrealistically restrictive (such as "you cannot assume negative integers are represented in 2's complement).