cristeigabriel

What a bullshit response.

And we help them out for their own sake, so that they can live a life of their own eventually.

I think you forget the fact that his son has 0 ability for self-preservance. In some cases, we may make things that have no chance to exist on their own, persist, but in this case, what does it serve, but our own selfishness?

I believe it's selfish to keep somebody going when they have absolutely 0 ability for self-maintenance.

Seconded. For reference, I have experience with this kind of scenario first hand (helping care, and living with, somebody with dementia combined with complete immobility and many other things making the quality of life for absolutely everybody involved worse). I hope that with time we become more comfortable with euthanasia, most of us in the scenario found it to be the right choice, but society goes against it.

The questions would come from reading a paper in particular. Have a question? Ask away. That's how I'd use it personally.

I am aware. I am asserting the distinction there.

Since words have to mean stuff, I would definitely call it immediate mode, it's not trivial at all to hack a generic retained mode UI library into being as flexible to what's on screen as ImGui. A generic retained mode design would more rather require pointers to some dependency state to check per update, with ImGui the schema gets rebuilt constantly, instead of being reactive. And there is definitely use cases for this design, constantly changing stuff would probably fit with Dear ImGui or others better than with a generic retained mode UI toolkit.

It does require some state in the back for everything to work as it does.

I think it fits, Dear ImGui is the most popular immediate mode GUI, and it's what most people think of when they hear "imgui" even though I've seen people shorten "immediate mode GUI" to "imgui" too.

ImGui supports multiple text rasterizers.

Egui is not the "Rust version" of ImGui. There's libraries which allow for ImGui in other languages by applying the hourglass pattern first (making a C api for the C++ api), to allow for the creation of bindings, since most languages support C FFI, and then somebody writes an API in the target language which calls to (and maybe extends) the C api.

I believe you mean the (general) transparency of state? But yes, that's quite great when you're getting stuff together quickly. It's even used for more serious stuff, where immediate mode is a necessity.

Seconded!:)

Do you have something like exceptions and segments? Itd be cool if it didn't IMO (besides for permission situations, I guess)

So lovely!

Thanks for sharing!

It makes sense, it's a perfect advertisement of their superiority.

Very nice. A parallel, I've been working on an emulator project recently, implementing my own disassembler, and I keep thinking about how I would turn patterns of machine code into a generalized form, which could then be turned into something like C-like pseudo-code, so it's been really compelling me lately to implement my own toy decompiler

To advertise "finesse of macOS", you should deliver on that

Whilst I agree, it was just a development on what I perceive to be their vision. I address this particular point in another comment in this comment thread.

Sure, but I don't think that is the issue here.

I think there is a critical error in the judgement you make here, we can see that they advertise[0] the finesse of macOS. But what does this really mean? Let's think about it.

But before that, they clearly must be aware that... it's just bad (lightly put), yet it comes off very clearly that they're trying to copy[1] visual elements of Mac. So what does the author think finesse mean?

For my perspective, I'll quote the first definition I get on a Google search, "impressive delicacy and skill." We can argue that Mac does provide this (I believe it does, the experience is very opinionated (which also leads to stuff being intentional) and seamless across their devices, consistent (more than just the potential for consistency, which is what Windows provides), and so on, and so forth.

But, this is nothing like what we see in the current RavynOS. Nothing feels intentional. The advertising is misleading, and I don't think that it's something solvable in the future unless the person responsible for advertising and guaranteeing the presence of this "finesse" update their understanding of the word and clearly defines what that should mean in practice.

Update1: to add to my previous points, if my perception of the word "finesse" is correct, for something to have the "finesse of macOS," it wouldn't even have to look like it, but just achieve the same goal in it's own way (or Apple's way, that's "fine" but leaves a bad taste.)

[0] - https://ravynos.com/ "Finesse of macOS. [...]"

[1] - https://ravynos.com/screenshots

It just looks bad. You want to be MacOS? Actually go and copy it, as close to pixel perfect as you fancy.

I've personally experimented with replicating UIs using just a "device" object to a graphical API, so I know very well that it is possible. What prevents this project from just... going out and actually doing what they're trying to achieve? Take high resolution screenshots, carefully understand what's going on, and re-implement it.

The hardest part would probably be compositing (if they do it from scratch), but even before getting there, there's so much wrong already. This really does not have the same finesse of MacOS, has anybody even looked at the screenshots picked by the developers??

Maybe Grammarly doesn't work for Chromium? (guessing)

If Chrome is able to generate a crash-report, nothing would prevent you to intercept it.

> Unfortunately, with access to neither the Chrome source code [...]

I mean, it's still very possible to debug (especially with the fact in mind that Chromium is open-source, and for me has been a very useful source when reverse-engineering and debugging Chrome), but I understand why web developers would not be trained in reverse-engineering techniques.

`&&` and `||` are very well defined (for the better part, there's languages where `||` does more than just Logical OR.), this double-not hack is just a hack, and can be achieved in many more ways. Stop trying to be obfuscatingly clever, the right time and place for that is outside of professional environments. You don't go around applying tricks from Hacker's Delight without explaining them, do you?

This is not the same at all. What OP does is a *hack* to convert some arbitrary value to a number. This should be very explicit, to avoid having 9999999999999999999999999999999999 and 1 more way to do the same thing.

reminds me of `!!` which has been more common in my experience, as a way to coerce something negatable into a bool.

> This is obviously a fair bit slower than ~~.

I don't think the code posted before this comment is particularly fast, but are we sure this double-not is faster?

I heard that apparently the M-series chips have some dedicated hardware for emulation, I may be wrong however. Not sure though how it's powered, and how it does the emulation itself afterwards. It very well could improve battery life if it does more than blind emulation. For the opposite end, look at QEMU (kind of an unfair comparison since Rosetta seems to be more like an userspace emulator, whereas QEMU handles a ton of devices and more)