• 0 Posts
  • 78 Comments
Joined 3 years ago
cake
Cake day: June 13th, 2023

help-circle



  • Hard no, with an Nvidia GPU you absolutely should go for a distro like Bazzite to avoid the driver headache.

    I switched to AMD for my own use a long time ago because of how this used to be the case, so I can’t verify this for myself, but… these days, isn’t that no longer an issue for anyhing newer than Turing? I see RTX 3060 TI in there, which should be fully supported by the open-source drivers that NVIDIA themselves recommend for that hardware, no?

    Again, I could be wrong since I haven’t had direct personal experience with it since the days when I DO know that your statement accurately reflected the NVIDIA GPU + Linux driver situation.



  • If shaders don’t get preprocessed, then a lot of the same work has to happen later, it just shows up as a seemingly random frame that takes particularly long to render.

    (edit to add:) or a section where some of the rendering doesn’t look quite right initially, if they do asynchronous rendering.

    In the limit, the sum of all these delays can add up to the same amount of time that the preprocessing WOULD have taken, but you also don’t necessarily use every shader every time you play every game, so YMMV.




  • JPEG also supports lossless compression.

    Technically, the spec does require it, but given that we’re in a thread about ecosystem support for a file format that’s approaching its 15th birthday, it’s worth considering how many image viewers will actually be able to work without the DCT step that is the essence of what typical JPEG does.

    I don’t have a Windows machine handy to test, but it’s entirely possible that maybe lossless JPEG won’t display in its default viewer.


  • “This committee is very sorry to hear that Mr. Mueller is too sick to face our bullshit allegations…”

    ? What bullshit allegations? The article says that this is the subpoena that they are dropping:

    “Because you were FBI Director during the time when Mr. Epstein was under investigation by the FBI, the Committee believes that you possess knowledge and information relevant to its investigation,” committee chairman James Comer wrote in an Aug. 5 letter to Mueller, directing him to appear for deposition on Sept. 2.

    To me, this sounds more like “oh noooo, I guess we can’t get any more details about the Epstein stuff, better luck next time”.

    I’ll leave it to someone else to speculate over whether or not they think that he would get the same treatment if the subpoena were to testify over other matters.







  • Second one was, IIRC, one of the primary motivating use cases for IAsyncEnumerable<T>. It has to be IAsyncEnumerable<T> all the way up and down, but it’s elegant enough. Quite often, depending on the API, it might naturally be implemented by a variant of “paging” behind the scenes. One advantage here is that since the updates throughout the final await foreach can happen entirely on the UI thread (assuming a compliant SynchronizationContext.Current, which is the case at least for WPF), you can see the results streaming in one-by-one as they arrive from the original repository if you want.

    Before watching the video, from the title, I correctly guessed what the first bug would be, but my guess for what bug #2 would be was one that’s more related to the far more insidious one that he describes starting at 17:27. You don’t have to get very fancy to see connections held open too long:

    I don’t know how common it is more broadly, but I’ve seen plenty of code that overlooks using and just directly calls Dispose (or, more commonly, a Close method). While it’s generally advised to favor using over directly calling Dispose, admittedly it’s not always a huge deal: if you don’t otherwise have a robust story for what happens when exceptions get thrown, then it doesn’t ordinarily matter that you’re not explicitly cleaning up those resources, since the program might just be ending anyway.

    With iterators, this can leave the connection open even if no exception is thrown. try/finally blocks (including using scopes, which I assume still get lowered to the same) get extra treatment to make sure that the finally part gets executed when the iterator is disposed, which happens at the end of any foreach loop over it (including the implicit loop behind calls like .First).