JCWasmx86

I use Signoz for my private purposes, it's not a 100% match, but you can do Prometheus metrics, logs analysis, dashboards, alerts, OTEL spans so depending on your usecase it can be enough

Or meson is a serious alternative to cmake (Even better than cmake imho)

If the GDPR is simplified, the fines should be drastically raised. (At least for companies) E.g. to minimum 20% of the global last years revenue, for bigger companies (FAANG-Scale) to minimum 70% of the revenue. The GDPR must make companies afraid of breaking the law.

The biggest symbol of a statically linked swift binary that I have, is icudt_swift65_dat with 27.98MB, so I think that's not so easy to remove (nm v3.1.2 --size-sort --radix=d|swift demangle) And I think if you strip debuginfo it will be smaller (For a statically linked program of mine: 98MB -> 56MB)

But I think for a distribution it makes more sense to link swift programs dynamically against the runtime libraries, like it's the case for e.g. the C standard library, OpenSSL etc., as you can assume they all work with the same version and are ABI-compatible.

I tested it with a nearly static build (Still links against glibc and friends): 55MB get stripped to 44MB, so not that much. 27MB of that is icudt_swift65_dat, so I guess you would have to optimise that first

Yes, but people still have the right to say "Pay us $X and ensure safe working conditions or we strike" Tesla can either withdraw or negotiate. Nobody's right is infringed here, it's just free market. Especially as usually the workers have it worse than companies.

One is a business decision, the other one is people exercising their rights.

You can do that with m3u8 files. This is done for example by Pluto TV. Sure it is easily circumvented by simply stripping out these URLs, especially if they are marked as ads (And removing a m3u8 tag)

But in the end it would be again an arms race of adblockers and Google, so it would change basically nothing.

Wouldn't even be checking Microsoft's server be an unnecessary connection? You could argue, that VSCode would still work, as updates are basically optional and could be triggered manually, too

It's easy to install on ArchLinux and Fedora. The build process seems to be just standard CMake, so calling it "borderline impossible" is really a stretch.

A lot of editors have available integrations for Shellcheck. VSCode and IntelliJ have a plugin, GNOME Builder comes with the plugin included, etc.

This really makes me reconsider buying an iPhone instead of some android phone in the future.

The only thing left is that jail-breaking an iPhone seems to be harder than rooting an android phone.

It's just a liability and risk. Imagine you have some mission-critical system written in such language, the vendor goes bankrupt or creates absolutely unacceptable terms. Then you have a problem.

Sure if something similar happened to an open-source project, you would still have to either hire engineers to work on the compiler/tooling/language or to rewrite it in a more supported language, but I would consider it a little less riskier as you aren't dependent on one vendor

No, you just have to follow the regulations. It's no "war on US companies" or anything like that. They wrote some good law (Albeit it has a few weaknesses), and enforce it now. And if you want to do business in the EU, you have to follow them.

I would say it's more a problem of the US companies, if they can't do business without violating EU regulations.

Would you say buying e.g. a Mac mini for 2.3k€ just to run Asahi Linux is worth it?

Yeah agreed. They will simply continue to violate the GDPR. If the last years global revenue was 116 Billion USD, the fine should be at least 200 Billion. Otherwise companies just will see the fine as cost of doing business.

Maybe something like gitweb? https://git-scm.com/docs/gitweb

I have not used it before, but it seems like it follows your requirements (Except auth using SSH keys maybe, but that could be a task for e.g. Nginx)

Does it respect DNT headers? If no, it does not respect users.

I recently installed Windows 10 in a VM to port a program to Windows (Was a horror story). On the left side in the start menu I have ads and other crap: "Trending searches", "Trending videos from the web", "Games for you", "Trending news" and some other stuff like a reminder for the International day for Monuments and Sites.

On the right side I have a weather/news widget from some really shady or local newspapers about "celebrities", a lot of clickbait, stock data etc.

And obviously the first time I opened Edge I was greeted with some annoying banner, that I should login etc.

A default installation of an OS should only come with the bare amount of software necessary. If they had asked: "Do you want to have news/recommendations? - Yes/No,never ask again" it would be really okay as there was no forced consent, but installing it by default is simply a bad decision. (From a users' perspective, it probably makes sense from a corporate perspective as otherwise they wouldn't do it)

Companies should really accept a "No" from their users. No I don't want to use a microsoft account just to use my computer. (Without jumping through hoops) Don't ask me again the moment I say "No".

You can see the same with all those dialogs that only have "Yes, do $THING" and "Remind me later".

Nowadays you can even use JS for GTK Applications

Reproducible builds. Sure not every project can be built in a reproducible manner, but it at least reduces the chances of getting shady binaries

Open source does not mean "I take random projects, integrate them into my product, without any credits, without any acknowledgments". It means "I take projects, integrate them into my product and follow the minor implications of the license"

For example the MIT-License has a rule:

    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

You could take it a step further and make the user download a small stub Actually Portable Executable (https://justine.lol/ape.html) which downloads the real binaries.

At least for me, pkg-config has auto completion (Fedora), so typing e.g. `pkg-config open<TAB>` would give probably give me some results. But I agree that's one weakness of pkg-config, that you have to guess the name a bit

You can use pkg-config for that. E.g. if you want to compile with glib-2.0, you can run `pkg-config --cflags glib-2.0`: -I/usr/include/glib-2.0 -I/usr/lib64/glib-2.0/include -I/usr/include/sysprof-4 -pthread (E.g. for compiling to object code, but not linking yet)

Add `--libs` to link against it, too: -I/usr/include/glib-2.0 -I/usr/lib64/glib-2.0/include -I/usr/include/sysprof-4 -pthread -lglib-2.0

With meson that is basically `dependency('glib-2.0')` that you add to your executable/library.

you expect your users to install your app dependencies for you, and you have to figure out the path of your own dependencies.

If you use a good buildsystem, it will find those dependencies automagically or you can e.g. use wrap dependencies: https://mesonbuild.com/Wrap-dependency-system-manual.html Those do automatically download the dependencies and compile them for you

One point that came with the web stack is the entire "We won't optimize for anything, we just want to release quickly. Disk space is cheap, unused RAM is wasted RAM, every PC has at least 8 cores" (Maybe a bit hyperbolic, but still somewhat right imo) And this is something that has to be reverted. Sure I don't expect every application to just use C/C++/Rust with carefully hand-optimized algorithms like back then when the C compilers were not that good at optimizing, but at least I would expect applications to be aware of weak hardware

the desktop/UI sucks, its awful in almost every way, you are essentially targeting X11 which was developed in the 70’s and it shows. It works and it brings a couple of quirky features to the table which are quite nice, but, in essence, if you love Linux, just forget targeting GUI desktop stuff, you need a graphics screen, a browser (for a real UI) and a terminal window – that’s it… there is the Wayland stuff but its far too early, it’s also disjointed, barley supported and is grappling with compatibility with legacy stuff…

When would you even want to target X11/Wayland directly? Just use a toolkit and ignore the underlying stuff. For 90% of the application it does not matter.

I find it difficult to see why this is going to change any time soon, the performance of a well written UI in a modern browser out-performs a native desktop application in every category of sped, usability and presentation for most usual use cases.

I always encounter the exact opposite. I've never found any web application with a good UI or any web application that outperformed a native one.

Could you imagine a future where desktop applications were built like this, and in every sense of the word, “portable between operating systems” with the experience being identical on all platforms…

This sounds more like a really crappy future, if anything looks everywhere the same. Applications must integrate with the "host"-OS.

The only reason the web stack is used for desktop applications is because it is a bit cheaper and less effort than writing a good - native application.

The lock-in argument is just a very weak one. At some point you depend on something. Oh, your HTML only renders fine in Chromium or you use Chromium only JS APIs - you are locked-in to Chromium now.

You have more complex programming languages like Rust/Swift that take comparably ages to compile compared with C due e.g. all the extra code that is generated and that has to be optimized by LLVM (This one is quite slow AFAIK, too).

C++ has its template instantiations with the same problem.

Another aspect is how much more the compilers optimize, compared to the "early" days, modern compilers can often beat human programmers at optimizing assembly in a reasonable time and can do a lot more complex optimizations. In addition to that, you can couple it e.g. with linker optimizations like LTO/BOLT and you have even longer build times.

I think another factor is the more and more dominant static linking model (Rust/Go/Swift). If I compile e.g. my program with the swift stdlib statically linked, it takes around 15 seconds for an incremental build, while using a dynamically linked stdlib it takes around 6 seconds. Sure it is just one benchmark, but static linking nearly everything won't have no impact.

What is it achieved through? Vendor locked, user and developer hostile native app stacks?

Yes, there is Vendor-lock in, you can't deny that. I don't know what you mean with "user-hostile" and "developer hostile".

I - as user - personally ignore anything web based, if there is a native alternative, as I prefer apps that follow the HIG and use the native toolkit of the platform. Sure I'm just a single person, so this is anecdotal.

And that’s web stack with access to system APIs.

No I fully disagree. A good UX is only doable, if you use native components and fully follow the HIG. I have not yet encountered a good webapp that is on par with a native app that does exactly this.

Anything web based is good for "one code base - available - but subpar - for many platforms", while native apps are "One code base - one platform, but a great experience" (Given you follow the HIG and use native components)

One extremely trivial example: I don't want to accidentally delete e.g. my files, just because some app thinks switching e.g. "Ok" and "Cancel" around is nice.

While yes, web apps have their uses, but they can't match good native apps even remotely.

rent-seeking bureaucratic moochers.

Sorry but no. That's like getting a speeding ticket and complaining about the fine. You break a law - you pay a fine. That is no rent-seeking.

Release open source software with license specifically prohibiting European companies from using them.

That's no longer opensource: The license must not discriminate against any person or group of persons. (https://opensource.org/osd)