@[email protected]
And all of this starts with the data itself.
Code is data. Data is code.

#GDPR lack of enforcement against US #BigTech shows that while you are right at a theoretical level, in practice we need to be extremely careful to not be fooled by lobbyists that work to replace law with "paper compliance".

It would be easy for a US company to argue they produce open source, with open formats and open API defined by "open standards" that they control.

Then, to keep everything unchanged, they might just take competitor out of the market with overwhelming complexity, unfair competition based on free tiers and by buying the few survivors (if any).

Forced interoperability might be a step further, but it's not enough anyway: both #Meta and #BlueSky interoperate with the #fediverse over #ActivityPub, but in fact they jusr harmed the fediverse without any user moving over here preserving their contacts.

In brief, to get Digital Sovereignty we need to get rid of US tech.

There is no alternative, only procrastination.
They key point is that source code must be open and available for all.  That takes away the chances of someone talking full control of the software and restricting the freedom otherwise possible.
I'd love if it was that simple!
Unfortunately, it's not.

Again, #Chromium is open source and its code is available for all.
Yet it's tightly controlled by #Google that shape it (and the #WHATWG "open standards") into one of the worse and most powerful surveillance and manipulation tools out there.

I agree that some #opensource projects might be useful to gain #DigitalSovereignty (think of #NextCloud for example), but only if when their development is not controlled by any corporation tied with external governments.

This cut out all biggest open source projects, mostly leaded by US corporations or their employees.
data in an open standard is another piece in the same puzzle.
Again, it's not so simple: for example both #OpenDocument and #OOXML (#OfficeOpenXML) are open standards, but in fact when you save in ooxml (docx, xlsx..) by #Microsoft tools, they include undocumented proprietary extensions that #LibreOffice cannot handle properly.

So again while proprietary formats always harm individual freedom and #DigitalSovereignty of nations, openness is not, by itself, enough to get them.

And yet, a proprietary format developed by a fully European company would harm individual freedom just like any proprietary format but, given the company would be only and fully subject to European law (no #FISA702, no #CLOUD Act, no #Trump...), it would still enhance the digital sovereignty of the Union over an open standard totally controlled by US corporations.

So things are more complex and you can't get any real freedom or sovereignty from buzzwords like "open", "free" or #foss.

So again, to get #digital sovereignty, first of all we need to be laser focused on getting rid of #US control over #UE computing, citizens and lawmakers.

Some Free Software and Open Standards may help achieving such goal, but just being open is not enough. And we can't wait for all european software to be free to achieve Digital Sovereignty.

@[email protected]

@[email protected]
If you're concerned about the US controlling open source - you can fork it.
This is a naive take: above a certain complexity, hard forks of a software is not licensing issue. So while you can legally fork #Chromium, nobody can really hope of doing so in any meaningful way.

#WHATWG standards are dictated by the most used browsers, that are all US controlled anyway. And that's why it's such a monoculture, with #Firefox there only to provide a little #antitrust warranty to #Google: the standard themselves are designed to work as entry barriers to the browser market.

So again, open standards do not provide #DigitalSovereignty by themselves.

Open source and open standards only work in this regards whene there are several independent implementation from each country, so that there is no way to lock-in users, companies and countries' administrarions.

Without existing, multiple alternative, independent and fully interoperable implementations, open standards just reinforce centralization as Google proved when even #Microsoft abandoned their browser engine.

Then sure, #FreeSoftware helps with Digital #Sovereignty, since (and as long) people's #freedom is its primary concern.

But it's important to not conflate individual freedom and autonomy with digital sovereignty!

If all of your country payments are handled by US corporations, you might well use #GNU/#Hurd on your open hardware, but you are not free and your country has no sovereignty.

If all of your health data are stored by US corporations, they might well only use free software on open hardware located in your neighbourhood, but they are alware at a ssh of distance from #NSA, so you are not free and your country has no sovereignty.

What about your judges or your lawmakers exchanging unencrypted emails over #gmail or #outlook365?
Again, they can use opensource only, but you are not free, your country has no sovereignty and your vote is worth nothing.

So sure, after getting rid of US Tech we might even move to a #FOSS only stack EU-wide.

But first and foremost we need to break free from US control and surveillance.

Some opensource projects may help to ackieve this urgent goal.
Biggest ones won't and we shouldn't naively argue that going full opensource is per se useful or required to gain #DigitalSovereignty.

@[email protected]

@oblomov I've finally finished up my thoughts on a future of a #WHATWG with #PaleMoon in it, it was lengthy so I had to post it in the forum as well for feedback there. I promise I was not intentionally ignoring your question to the Pale Moon fedi account two months ago lol: https://forum.palemoon.org/viewtopic.php?f=65&t=32914

@konnorrogers Also, does this sound like Turbo? https://github.com/whatwg/html/issues/11542 Lots of fun APIs under discussion at the #whatwg session at #w3c #tpac

@[email protected]

#Fossil has way more feature than #git, so much you need a separated forge to fill the gaps a little.

Yet, if you compare fossil and git, the former is way smaller than the latter.

So fossil is both simpler and more featureful, while still looking less "modern" because it clashes with the industrial aestetics of the day.

To me, being able to actually read and modify its source code without being overwhelmed by its complexity turns it to a convivial technology: it's not built to reduce users' and developers' degrees of freedom either through standardization or ui/ux, but to enable them to adapt it to their needs, actually increasing their degree of #freedom.

I think the tension here is rougly the same I see between #C (and #hare) and #Rust, between #Make and #Ninja, between #TinyCC and #LLVM (or #GCC), between #GTK2 and #GTK4, between #SysV and #systemd, between #BSD (or #9front) and #Linux and so on.

Due to the constraints of their age, some older tools are inheritally more suitable to build convivial technologies than other.

Corporations need to alienate their workers, to reduce their degree of freedom, to make them easy to replace. It's not just power play: it's somewhat intrinsic into the need to sell (and thus produce) standardized products that can appeal to many (and thus provide large profits) instead of creating custom solutions for the exact issue at hand that may be orginal, beautiful and tuned to the specific aestetics and goals of a specific (and maybe small) group of people... but need care, access rules and, in general, a community.

Software complexity only really serve industial (maybe militar-industrial) needs.
More often than not, against users.
Always against #developers.

The number of browsers shrinked after #Google launched #Chrome and lured #Mozilla to destroy #Firefox credibility, because a handful of corporations control #WHATWG (and #W3C). #HTML5 requires an overcomplicated #JS engine and #CSS got variables and calc and so on...
And don't even get me start about systemd. Or Linux's 500+ system calls.

C sucks in many ways but there are tons of compilers. Rust looks so "safe" (and is so hyped) that people rewrite working software with it (under permissive licensings that only benefit corporate interests) causing DoS in the wild. And nobody give a shit about the big picture that such incident shows!

But that's the fact with capitalism: it requires deep cultural homologation and submission, so that most people push in the "right" direction by themselves. They may vote differently, dress differently, care about different value but they all need to accept the basic assumptions that enable profit maximization.

Such push to complexity and homologation was lower decades ago because computers were slow and the field was still new.
Thus we got pearls like #forth, #Lisp, #Pascal/#Oberon and so on... even Linux, back in the early 2000 was a convivial technology designed more for people's (developers are still people) needs than for corporate needs.

Now Fossil is in fact modern technology, but it's built on a shitty language (with tons of implementations) that caps its complexity. And I think this is a sort of long term warranty about its usability in convivial contexts.

(sorry for the long reply... grow out of control... I guess this is something I was reasoning about since ages but never had an occasion to formulate...)