Even having it as a private repo on github is a mistake at this point.

Self hosted or just using git itself is only solution

Burning money might actually be a legitimate thing to do since it causes deflation as far as I can understand

Deflation is a very bad thing...

Of course it is. Things getting cheaper is really bad for the economy.

That's why computers never became an industry, they just kept getting cheaper every year so nobody bought them. If only computing power had kept getting more expensive every year, we might have some kind of tech industry!

A single (luxury) sector getting cheaper is not the same thing as generalized deflation

Computers are not a luxury sector, they're practically built into every device because they're so cheap.

They're also hardly a single sector. What does growth look like if you remove tech stocks?

In the traditional / academic sense of the word, it _is_ deflation. The repurposing of inflation/deflation to refer to consumer price action is much more recent.

This requires O_SYNC and O_DIRECT afaik.

Even then it is only some file systems that guarantee it and even then file size updating isn’t atomic afaik.

Not so sure about file size update being atomic in this case but fairly sure about the rest.

Matklad had some writing or video about this.

Also there is a tool called ALICE and authors of that tool have a white paper about this subject.

Also there was a blog post about how badger database fixed some issues around this problem.

I don't think any part of your post is right. Aside from NFS, there should not be filesystems where this doesn't work. If there are, those are just bugs. The flags you mentioned are not required or relevant. Setting the fd offset to the end of the file atomically is the entire purpose of O_APPEND.

It depends on what you mean by atomic. If it is only writing to page cache and you are writing a small amount then yes?

If there is a failure like a crash or power outage etc. then it doesn’t work like that.

You might as well be pushing into an in-memory data structure and writing to disk at program exit in terms of reliability

You are projecting imaginary features onto O_APPEND and then hypothesizing that your imaginary features might not work.

POSIX says that for a file opened with O_APPEND "the file offset shall be set to the end of the file prior to each write." That's it. That's all it does.

I am assuming the author doesn’t know much about how this flow actually goes since he didn’t get into that at all.

It is annoying to see a complex field as law being judge by stock prices of some SaaS products or w/e they are basing this on.

Could have at least gave it some effort and interviewed 2-3 people that use these kind of products but that would be too much work surely.

It is not surprising that people that slop like LLMs are so into LLMs

> It is annoying to see a complex field as law being judge by stock prices of some SaaS products

They're not judging the whole field of law, they're judging the SaaS products themselves. In fact, relevant expertise from humans has probably become more valuable not less, as a result of general AI worflows replacing bespoke SaaS.

As far as I can understand, these tools are not intended for the author and he doesn’t use them. And seems like he didn’t even contact someone that does use them. So I don’t see any connection

This sounds nothing like my personal experience. I was able for play every single game I tried including

Asetto corsa competizione

Basically all total war games

Cyberpunk

Witcher 3

Dishonored

Mafia 1 and 2

AC origins/odyssey

Civilization 5

Detroit become human

Prey

Crusader kings 3

Stellaris

Metro exodus

And more games I don’t remember

I don’t enable ray tracing or resolution scaling so that might be making the difference on games that have it.

Chances are you can run it if something is at least gold on protondb

Also my gpu is amd.

As a side note, I played cyberpunk for more than 400 hours on max settings without any major issue so saying it doesn’t work because of rtx is very silly imho

LLMs had no impact on how content is organized as far as I can tell.

Some people are just using it to post more garbage into the platforms they already were using

Who would believe someone that writes something like this online?

I have been using kde for years now without a single problem. Calling cpp garbage sounds wrong.

KDE is a great desktop environment , but it's also notorious for being a buggy and unpolished DE [1]. It's good your experience wasn't like that, but it's certainly not how the software is generally perceived.

[1]: Of course, different versions have different levels of stability. Also, some of these bugs and problems wouldn't be prevented by using an alternative language such as Rust.

Well FWIW, the original poster's anti-C++ statements aside, removing the borrow checker does nothing except allow you to write thread-unsafe (or race condition-unsafe) code. Therefore, the only change this really makes is allowing you to write slightly more ergonomic code that could well break somewhere at some point in time unexpectedly.

Nope. Anything which wouldn't pass the borrowck is actually nonsense. This fantasy that magically it will just lose thread safety or have race conditions is just that, a fantasy.

The optimiser knows that Rust's mutable references have no aliases, so it needn't safeguard mutation, but without borrow checking this optimisation is incorrect and arbitrary undefined behaviour results.

People who can't do something, sometimes assume nobody else possibly could.

People hate C because it's hard, people hate C++ because it truly is rubbish. Rubbish that deserved to be tried but that we've now learned was a mistake and should move on from.

I’m sure some people could tiptoe through minefields daily for years, until they fail. Nobody is perfect at real or metaphorical minefields, and hubris is probably the only reason to scoff at people suggesting alternatives.

Just FYI rust projects have CVEs as well.

Of course. My sense is there are a lot fewer in of out-of-bounds accesses and use after frees. Maybe a world-class programmer can go several decades without writing a memory error in C/C++, but they will probably eventually falter, meanwhile the other 99.9% of programmers fail more often. Why would you decline a compiler’s help eliminating certain types of bugs almost entirely?

This is bean counter mentality. Personally just don’t believe this is how it works.

The intention/perspective of development is something on its own and doesn’t correspond to the end result directly.

This is such a complex issue that everything comes down to what someone believes

It uses zig as a build system instead of something like cmake

Why though? It seems simple enough that a makefile and perhaps a configure script would suffice.

> makefile and perhaps a configure script

That's a lot to ask for on a non-UNIX system like Windows, and you still also need a C/C++ toolchain (which is typically provided by a Visual Studio installation, which has neither a compatible 'make' nor 'configure').

The next-best alternative would be cmake, but that's a complex boondoggle of its own.

PS: also the toplevel cmdline tool seems to be written in Zig, which might be more convenient than C just because of the Zig stdlib.

That's surprising to me because Meson/Ninja C project configuration is generally just a handful of lines of text and I can't imagine it getting much simpler than that

...just installing Meson on Windows is so complicated it has its own special section in the documentation ;)

https://mesonbuild.com/Getting-meson.html

Yeah this feels like it could be packed into a pair of .c source file and header.

It is just a tool so I guess they already know it and it is good enough.

I also know zig build system really well but learning cmake now. I might have used zig too if I had to build something right now