javbit

> These filters ruin the retro pixel art look by making things blurry, making larger pixels, introducing a screen door, and more.

I think there's an argument that pixel art was designed for CRT displays and thus optimized for it. I think of it like Pointillism: the work is made of little dots, but the point is for you to see the entire work blend together. And for low resolution works like retro games, they often hold up well on CRT (especially real ones). However, I think modern games with the pixel art aesthetic look best crisp.

To each their own tastes, though.

I daily drive bith RDE/GNUguix (personal) and NixOS (with home manager) (work). Both work really well for my needs.

Pros for guix: - guile scheme - better documentation - free software first - strictness means things blow up early - great emacs mode!

Cons for guix: - goofy stack traces (guile debugger is nice but im not very proficient)

Pros for nix: - more packages & services - flakes, which makes it easy to lock in versions, though guix has channels. Flakes just feels easier to me imo. - laziness - sometimes better error messages

Cons for nix: - laziness (infinite recursion) - no debugger afaik, have to use repl which is useful but also sometimes clunky

Good resource on guix is system crafters (David Wilson)

https://systemcrafters.net/

It's not strictly free software as it restricts freedom zero, the ability to use it for any purpose.

https://www.gnu.org/philosophy/free-sw.html#four-freedoms

It's interesting because I'm sure no free software author wants to inadvertently support a dubious cause. This clause prevents that (in theory at least, as license enforcement is hard for everyone). However, it also nominally prevents use by good causes as well (you can grant exceptions). Good and bad here are relative to the author.

I guess it's a balancing act between upholding ones own sense of right and wrong, and the freedom for someone else to have a differing opinion than you.

You could probably use Shamir Secret Sharing so you'd need to have k out of n parts to recover the information. Downside is that this complicates what is supposed to be simple.

edit: I see other commenters shared this idea too.

If the display of the code is removed from its representation, I think the same could be done for comments. Comments could be kept as part of the AST and rendered how you like.

E.g.

    (+ 1 2)  ; Add two numbers.

Would become

    (comment (+ 1 2) "Add two numbers")

With semantics like const.

Another would be

    (+  ; Adding
     1  ; one
     2  ; and two.
     )

To

    ((comment + "add")
     (comment 1 "one")
     (comment 2 "two"))

You could display comments as popups, marginalia, or even in a traditional fashion (since some intent is captured by the comment scoping. You could also have different types of comments like annotation to have different kinds of display types.

Yeah, I realized after I wrote my initial comment. Sometimes tangential thoughts just hijack your mind :D

I tried an SSRI for a month, after the first week I was getting into more arguments for no reasons. Usually I'll have some (at least vague) lucidity as to why I'm upset, but at that time I didn't and it made me feel quite stupid. Never doing those again.

I think I read somewhere that Aboriginal Australians have oral tradition that mentions rain forests covering much of the continent. I wonder if these are the same (edit: perhaps remnants of, since the fossils are dated in the millions of years) forests that the article mentions.

If anything, really shows how the “traditional” knowledge that I personally did not consider much before may be worth taking a second look at.

We learnt some non-standard in a logic class (as a capstone application of FOL and model theory).

Perhaps there’s a perceived notion that to understand infinitesimals and such you need a logic background, but logic classes are generally an upper-half class that doesn’t have a full track for undergrads. This would be in addition to the fact that most professors are familiar with ε,δ-proofs and AP calculus classes cover the limit approach (though not rigorously).

The entrenched pipeline of mathematics students and professors would have to face a period of getting flushed out and refitted, and this is probably not attractive to administrators.

It should be called something like appendixgun then because you don't use it but it still has a chance of causing needless suffering and pain.

You could detect if stdout is a terminal and then decide for fanciness or machine readability. I think this, along with flags for manually setting rich features, would provide the best of both worlds.

I got bit by this when scheduling an interview. It's interesting because it's not that much harder to say America/Chicago (or just Chicago) but it's just by default I tend to say CST, CDT, etc. Started using UTC offsets but not many people know those off the top of their heads.

Would

  withFADR' :: (FragileAndDangerousResource #-> IO ()) -> IO ()

be a better type? My reasoning is if I use the linear identity function

  lid :: forall a. a #-> a

in the following

  withFADR lid

I should be able to “break out of” the managed context [1] by the types. Using

  withFADR'' :: (FragileAndDangerousResource #-> ()) -> ()

is obviously not right since nothing could be done with the `FragileAndDangerousResource`, so I think side effects are necessary.

---

[1]: I'm assuming that's what you're going for with `withFADR`.

I've had these symptoms my whole life (and still do), so it makes me wonder if already having chronic visual disturbances can play a role in developing or "preventing " [1] HPPD.

[1] If you already have the symptoms can you get HPPD?

Could this, however, be used to create random bit streams for use in one time pads? I'd imagine it could solve the problem of sharing the large keys beforehand since you could generate it on the fly.