• 0 Posts
  • 10 Comments
Joined 2 years ago
cake
Cake day: August 15th, 2024

help-circle




  • +1 for Reddit API exodus.

    Lemmy was sold to me as a Reddit replacement. And it is, superficially. I knew it wasn't going to be drop-in going in. But the longer I use it the more I think it's not really quite like Reddit, and never will be. And that's fine. Lemmy is its own character and I like it for what it is.

    I still use Reddit. Lemmy doesn't scratch all the itches for me. But only old.reddit on the desktop and on mobile with a UI de-shittifying extension. I'm amazed they still offer it at all. Once that's cut off, something I've been bracing myself for for years, I'll consider the UX enshittification to have fully completed and I'll truly bail. I simply refuse to use their gentrified UI. And I'm tired as it is having to slap on compatibility layers just to keep their less terrible alternative on life support; I'm not going to do the same thing to make their mainstream UI somewhat more palatable.


  • I've personally always loathed the global menu bar paradigm of macOS. Having a menu bar that's wholly detatched from the currently open window that is context-aware based on which window has focus always felt like an irritating speed bump to me. My mind feels like the OS itself is hiding things from me by only allowing me to see a single app's menu bar at a time.

    But then again, I have no objective qualms with it. I'm sure I could adapt to it. When have I realistically needed to see more than one menu bar at once? I can't name a time. I'm probbably just pearl-clutching at the perceived arresting of my agency to do things when in fact I'm losing effectively nothing.

    At any rate, we agree it's a sure sight better than the shitshow that is GTK. "Hm? Window decorators and shit? Nahhh, those are your problem. Go roll your own." For the flagship windowing toolkit of the GNOME Project, the DE I'd consider the closest in philosophy to what macOS has going on, that was a rather strange position to take.


  • I do honestly miss the level of artistic and aesthetic polish that a multi-billion dollar corporation can afford to field that no Linux distro really can.

    Linux as a rule is and always has been generally quite "Guys Live In Apartments Like This". Often utilitarian to a fault. UX design by backend devs, because actual frontend devs cost money. No one wants to pay the "beauty tax" for software. DEs like KDE and Gnome are trying very hard and have made great strides, but it's very slow progress.

    And I imagine this comment will be a magnet for power user types who will flock to my post and retort something along the lines of, "All that stuff is bloat/a usability nightmare/clutter/gets in my way/comes at the cost of features", blah, blah, blah, waaahhhh boo hiss... Yes, it's all true, and yes, I understand. But Linux and the free software it surrounds itself with tends to be crusty, clunky, and god-awful ugly, and I'd be lying if I said that didn't frustrate me a bit now and again. Does it bother me to the point that I don't want to use it? Fuck no. Windows isn't worth the bullshit. But they do at least know how to make an OS slick and beautiful, when it works, anyway.

    I'm sure people will also cherry pick examples of FOSS software that are quite ergonomic and lovely to feel. Yeah, there are many examples that exist, but they tend to be diamonds in the rough rather than exemplars of the ecosystem. For every one dev in this community who actually has a fucking clue how to make smooth-feeling and aesthetically pleasing software, there's a score of devs who slapdash together their programmer-art-tier UIs and call it a day, and a thousand other dev-brained users who look at it and go, "this is fine". And yeah, it is fine. But sometimes I want more than fine.



  • I recognize three kinds of comments that have different purposes.

    The first kind are doc block comments. These are the ones that appear above functions, classes, class properties, methods. They usually have a distinct syntax with tags, like:

    /*
     * A one-line description of this function's job.
     *
     * Extra details that get more specific about how to use this function correctly, if needed.
     *
     * @param {Type} param1
     * @param {Type} param2
     * returns {Type}
     */
    function aFunctionThatDoesAThing(param1, param2) {
        // ...
    }
    

    The primary thing this is used for is automatic documentation generators. You run a program that scans your codebase, looks for these special comments, and automatically builds a set of documentation that you could, say, publish directly to a website. IDEs can also use them for tooltip popups. Generally, you want to write these like the reader won't have the actual code to read. Because they might not!

    The second kind is standalone comments. They take up one or more lines all to themselves. I look at these like warning signs. When there's something about the upcoming chunk of code that doesn't tell the whole story obviously by itself. Perhaps something like:

    /* The following code is written in a weird way on purpose.
    I tried doing <obvious way>, but it causes a weird bug.
    Please do not refactor it, it will break. */
    

    Sometimes it's tempting to use a standalone comment to explain what dense, hard-to-read code is doing. But ideally, you'd want to shunt it off to a function named what it does instead, with a descriptive doc comment if you can't cram it all into a short name. Alternatively, rewrite the code to be less confusing. If you literally need the chunk of code to be in its confusing form, because a less confusing way doesn't exist or doesn't work, then this kind of comment explaining why is warranted.

    The last kind are inline comments. More or less the same use case as above, the only difference being they appear on the same line as code, usually at the very end of the line:

    dozen = 12 + 1; // one extra for the baker!
    

    In my opinion, these comments have the least reason to exist. Needing one tends to be a signal of a code smell, where the real answer is just rewriting the code to be clearer. They're also a bit harder to spot, being shoved at the ends of lines. Especially true if you don't enforce maximum line length rules in your codebase. But that's mostly personal preference.

    There's technically a fourth kind of comment: commented-out code. Where you select a chunk of code and convert it to a comment to "soft-delete" it, just in case you may want it later. I highly recommend against this. This is what version control software like Git is for. If you need it again, just roll back to it. Don't leave it to rot in your codebase taking up space in your editor and being an eyesore.


  • Detective Heart of America: The Final Freedom is a comedy film that will either be the funniest thing ever or an absolute cringefest, depending on your opinion of Jason Steele's brand of humor. There is no in-between. It's available to watch for free on YouTube, or whatever alternative frontend you use.

    Jason Steele, AKA FilmCow, you may recognize from YouTube series such as Charlie the Unicorn or Llamas with Hats. Yeah. That guy. Imagine 70 minutes of that.

    The film is a sequel to a pair of 4 minute long shorts (here and here). The film contains characters from these shorts and references events from them. So watching the film without watching the shorts first leads to some characters showing up out of nowhere with unexplained details. But that's how every other character in the movie is, so... whatever, lmao.

    I still recommend watching the shorts first. If nothing else they can serve as an appetizer for you, to decide whether or not it's your cup of tea. The film is the same vibe as the shorts, just longer. If you hate the shorts you will despise the film.

    It's unironically my favorite film, so, I hope you get some amusement out of it. But if you bounce right off, I won't be surprised. If you like it, enjoy quoting every line of it for the next month. If you hate it, sorry for wasting your time.