Readit Newshttps://en.wikipedia.org/wiki/Abu_Omar_case
This is well know case of a "person of interest" kidnapped by the CIA in Milano, Italy. While the CIA was assisted by the Italian Intelligence, it was a completely illegal operation, without any due process or judiciary oversight.
[1]: https://en.wikipedia.org/wiki/Seeing_Like_a_State
[2]: available free to read online: https://files.libcom.org/files/Seeing%20Like%20a%20State%20-...
on my work computer - there's a sep. 365Copilot app that is tied into Teams,Sharepoint, outlook, and I believe our engineering wiki. Probably other stuff I'm not aware of.
I'm honestly shocked how often I use it now.
If I get a random Pipeline failure; I'll copy/paste it into the o365 Copilot app - and it points me to an email I didn't notice ~3 months ago about a new policy change, and then points me to discussion thread I wasn't on ~2 weeks ago about how to get in compliance with direct links to EngWiki 'how to fix..' documentation, and an Teams link to join the breaking teams Office Hours.
Just off a single ~1 sentence prompt and a stack trace
It's kind of amazing.
In this case your absence from the thread was probably an oversight, but in general there could be a very good reason for it
The same guy did similar when his mom was on her death bed. Jesus Christ.
I had a clear simple straightforward mental model of how Lisp and PostScript references and also C pointers worked, which only misled and confused and disappointed me when thinking about Perl:
https://donhopkins.medium.com/the-shape-of-psiber-space-octo...
When I sat down and tried to type my simple straightforward design in as Perl, I suddenly realized that you can't have a reference to something that doesn't have a name, and that Perl name based references, as much as they masqueraded as C or C++ "&" syntax that takes the address of an object, were a TOTALLY DIFFERENT THING.
Perl loved to cherry pick and amalgamate the syntax of other languages (usually terrible languages like bash and awk), presumably to "help people who know that language learn Perl easily", but without any of the semantics, which actually makes it MUCH harder to learn, because "&" LOOKS like C but behaves completely differently and is much more limited and quirky.
You don't have to assign a C value to a global variable in order to take its address.
The syntax and choice of sigils isn't the hard part about learning a language, and if you get the semantics wrong, imitating just the shallow surface syntax of another language that got the semantics right only confuses and disappoints.
When you haphazardly mix and match the "syntactic sugar" of many poorly designed languages together into a discordant stew of artificial sweeteners with bizarrely different semantics, you get "syntactic syrup of ipecac".
Pre-Perl 5 (Perl 4 and earlier):
References were purely symbolic, built on typeglobs and package-variable names. You could only alias or refer to a variable that lived in the symbol table; there was no way to grab a pointer to a literal or temporary value, and you couldn't take a reference to a lexical (my) variable under strict. This made nested or nameless data structures effectively impossible without heavy manual bookkeeping.
Perl 5.0 (October 1994) — Hard references and anonymous structures:
Perl 5 finally introduced true, first-class references via the backslash operator (\) and the anonymous data constructors: [ … ] for arrays and { ... } for hashes. This let you write things like:
my $tree = { name => "root", children => [ { name => "leaf" } ] };
Explicit dereferencing, context-sensitivity, and autovivification:
Even with hard references, you must unpack them explicitly ($ref->[0], $href->{key}), and Perl’s context rules (scalar vs. list vs. void) can still be tricky. Perl’s autovivification feature (auto-creation of nested hashes/arrays on first dereference) eases some boilerplate—but can also surprise newcomers used to more explicit models.
How Perl compares to Lisp, PostScript, JavaScript, Ruby, Python, etc:
Lisp: Lists are built from cons cells and can be manipulated directly as first-class values, e.g. (list 1 2 (list 3 4)).
PostScript: Arrays ([1 2]) and dictionaries (<< /Key (Value) >>) are literal, nested, and don’t require separate pointer syntax.
JavaScript / Ruby / Python: All provide JSON-style literals ([1,2,[3,4]], {"x":1,"y":[2,3]}) and let you dive into nested structures without ever writing a backslash or sigil beyond the top-level container.
By not getting references right from day 1, then reluctantly iterating over decades on experimental hacks and after-the-fact syntactic baggage layered on top of the initial terrible design, Perl made trade-offs that cost much more than they saved from the self-inflicted problems they were trying to solve.
Fragmented syntax: Multiple dereferencing forms and feature-gated tweaks (postfix deref, autovivification pragmas) splinter Perl into a patchwork of behaviors.
Surprise side-effects: Autovivification can silently spawn large, unused data structures, leading to hidden memory/performance hits.
Subtle bugs: Context-sensitive rules (when autovivify, when not) remain a common gotcha, even for veteran Perl hackers.
Compatibility drag: Supporting both legacy 5.x versions and modern features forces extra version-checks, boilerplate, and warning squelches.
Cognitive overhead: Juggling backslashes, sigils, and varied deref styles demands a more fragmented mental model than the uniform list/map syntax of Lisp-style or JSON-based languages.
"The unspoken, right brain constraint here is that the complexity introduced by a solution to a design problem must be somehow proportional to the problem's importance." -Guido van Rossum
Edit: Of course Perl finally apes JSON-style literal syntax almost verbatim, but still has the old bad semantics, and getting there plastered over deep complexity you still have to cope with:
Feature-gated syntax: New deref forms (postfix, slices) require pragmas or newer Perl versions.
Autovivification surprises: Nested lookups can silently create unused data, bloating memory.
Multiple deref styles: Backslashes, braces, arrows and sigils—each with its own context rules—fracture your mental model.
Legacy support: To run on <5.24, you need version checks, warning silences, or to avoid modern sugar altogether.
Hidden complexity: Under the JSON-like literals lies a maze of sigils, contexts, and edge-case behaviors—far from the uniform simplicity of Lisp / PostScript / JS.
"Many, if not most" isn't good enough, because the edge cases always come back to bite you. You can't just rearrange the deck chairs on the Titanic and expect the ship not to sink. And sank it did, a long time ago.
The Perl syntax for this is pretty similar:
[1,2,[3,4]], {"x", 1,"y", [2,3]}
that can also be written, with a bit of syntactic sugar:
[1,2,[3,4]], {x => 1, y => [2,3]}
For many, if not most, cases, given a Perl data structure, the round trip "Perl -> JSON -> Perl" is transparent.
This is exactly how it works here in The Netherlands.
Is the heat produced inside a planet, mostly from the radioactive decay of natural isotopes.
Volcanoes are not powered by the Sun. Of course this production will cease when all isotopes will be depleted, but that will take a very long time.
But it is also totally irrelevant, because the point is that Washington was one of the richest people in America before the war started and even richer when he died. There is no doubt about that.
I'm doubting the different and very specific claim that "George Washington could have financed the entire Revolutionary War" with just a third of his wealth.
To me, the math simply does not add up. I suppose it can be chalked up to hyperbole ?
I also don't see how a discussion of the Iraq war could be relevant to that claim ...
A quick search gave me a lifespan of around 5 years for a starlink satellite.
If you put in orbit a steady stream of new satellites every year maintenance is not an issue, you just stop using worn out or broken ones.