> If China, Russia or both attacked the U.S. this way, how would we react?

I don't know, but I'm pretty sure all the janitors would be using Mop n' Glow to clean the floors, and they would have plenty of glass after. We could just rename the territories "Glass & Glow" for funsies.

M1 money supply is also down, and on a negative trajectory. Google M1 money supply and check the link at the FRED. Set the beginning of the time series to 2020-ish. It's drop roughly $2.5T or so from it's peak of about $21T or so. I don't think rates need further tightening, personally.

"I am not an AI, but venture capital investments in AI investments should include many phased plasma rifles in the 40-watt range."

Far nicer than some today, yeah. And getting better extremely rapidly.

WhatsApp has become largely irrelevant. Instagram is not far behind.

Basically, every time something is bought up by a megacorporation, people know that it's time to move on.

You can see a good discussion on quora (not the best source), but it's correct:

https://www.quora.com/Is-it-po....

Fun fact: ringworld and dyson spheres cannot "Orbit." They can spin, but they cannot maintain an actual, stable orbit.

It's all based on the idea that ringworlds/dyson spheres are orbitally stable. Neither are. No ring construct is (rings cannot "orbit").

> The "awkwardness" of the syntax is arguable

It really isn't. You would need to store the array allocated like in a struct along with something tracking its cardinally just to pass it around safely. Come on, buddy. You know it and I know it. Entire math libraries exist to ease the programmer with the abstraction management of it. Anyway, the issue is moot. You insulted me by telling me to "pick up a book" without asking what I meant by awkward, when the reality that extra book-keeping and arithmetic expressions are factually required: even by you for any "portable code," apparently.

You could just say, "oh I misunderstood what you meant, my culpa," you know? Rudeness was unnecessarily, added to nothing, and didn't help a single sole on earth understand anything better. It was pointless.

So if you scroll back up to my "non awkward" reference in my OP, it was referring to this, what "awkward" referred to was this:

int v3 = p3[2 * y * z + 3 * z + 4];

This is awkward. You can dynamically allocate multiple dimensional matrices in C# and dereference them unawkwardly like this:

int v3 = p3[x][y][z];

Python has a similar construct (through the numpy library), that is syntactic sugar for the same literal types of C constructs you are referring to. It just hides them and makes them "non awkward".

I've not used FORTRAN, but I'm told it's the same. Not sure.

Someone claimed on stack exchange that C99 could do better than your example, but now I have my doubts. But all you have done so far is confirm that I was right about my original statement. You could have at least asked what I meant about "awkwardness" before telling me that I was wrong. FFS.

Can you show the declaration and dynamic memory allocation mechanism you are referring to, so that we can be sure we are talking about the same thing? Two dimensional example is fine.

Dynamic allocation required discontinuity before C99. C99 fixed this.

I looked into this. I'm in the same boat as you. They updated the C standard in 99 (C99) to solve the double referencing problem of dynamically allocated arrays. So my comment describe an advantage that FORTRAN hasn't had for about 25 years. LOL. Anyway, it's good that I was wrong; it means C programs are faster now. ;-P

FORTRAN mainly beats C because the main, non-awkward way to use multi-dimensional matrices in C results in the matrix being allocated to non-contiguous memory. This is performance relevant, because this will cause the execution pipeline to stall.

Fortran fixes this. If you use the right keyword in C#, it also fixes it. The NumPy library, which uses an external C library, also fixes it, but that library is built using the "awkward" method I mentioned.

X development has slowed down because nowadays X skips its native GPU drivers and instead leverages the kernel's own GPU support via X's generic modeline driver.