I think, it can be important, because there are certain niche communities, which themselves have made it their mission to shit on the interest of others. Prime example is that weirdo linuxsucks community. It’s two folks who spend far too much time to find the wildest misinformation, which they think makes Linux look bad.
Leaving aside that it really is just absolutely terrible content, which I cannot imagine anyone browsing /all could possibly want to see, it also is just negative about something that people here enjoy, which I think is negative for Lemmy. Sometimes, they’ll even post stuff that’s borderline offensive and when you report it, well, guess who the moderators of that community are. Without contacting the instance admins to resolve that, downvoting is the only method of moderating a rogue community like that.

Oh yeah, you can, but it makes it pretty much impossible to discern between commits in the action run overview. So, if something broke between one change and the other, then you’d have to just kind of know what that change was.
That is obviously doable, if you make a singular change, then wait for the result before you make the next change. But I often had the problem that I would get interrupted or that I had to continue on the next day, so when I wasn’t quite as clear anymore what lines I changed precisely. Or what also often happened, is that I would get bored while I’m waiting for the action run to complete, so I start making the next change before I know whether the previous change was successful (I guess, this only really starts to become a problem, if it takes 30+ minutes for the run to complete).

But yeah, I put them onto a separate branch, so I can easily squash them into one commit before putting them back onto the proper branch.

The problem is that you end up using software that’s hosted on GitHub and then you’d like to report a bug or contribute a fix. You also don’t want to give your data to Microsoft. Both can be true, because the projects on GitHub don’t exist in isolation there.

There’s a comparison here: https://forgejo.org/compare-to-gitea/

Whenever I need to fix something with them, I go onto a separate branch, write a sane commit message once and suffix it with a “1”. Then the next time, I just grab the same git commit command from my history and change the “1” to a “2”, then to a “3” etc…

Yeah, my parents don’t seem to understand that this is actually work. To them, I’m just sitting there, having a bit of a chat with them. I now work in the field and they have become somewhat more sympathetic after I told them that this is basically another workday for me, when they call me to come on a Saturday or Sunday. Like, yeah, I will get around to it, but I am often exhausted from work, which does make it a pretty big ask for me to continue working on the weekend.

Well, yeah, but that Void type is different than the Void type in Haskell.

The Haskell-Void says that the function never returns. So, for example, if the function always goes into an infinite loop. Or only ever throws an exception or does a System.exit(0). You cannot portray that in Java, to my knowledge.

During the parsing step, you check that the list has at least one element. If it does not, you report an error to the user and exit. If it does, you take the first element in the least and store it in the left side of your tuple, and then the remaining elements of the input list go into the right side of your tuple.

So, for example: [1, 2, 3] → (1, [2, 3])
Or also: [1] → (1, [])
If the user gives you [], then you cannot represent that with your tuple, you necessarily have to error.

Yeah, the other person might take that as you already having looked at it and now you’re cautiously trying to tell them that it’s garbage. 🫠

To be honest, I’m still annoyed that middle names don’t have more relevance. Maybe five or so people know my middle name, all of which are family or relatives. Aside from that, it just makes it more complicated to fill out forms for various government organizations.

I’m a noob when it comes to digital music, but I’ve used LMMS and Ardour before.

I like LMMS a lot, because it’s relatively simple, so it doesn’t completely overload you with all kinds of features. Unfortunately, this can of course mean that certain features may be missing. For example, if I remember correctly, you can set a given beat (like 3/4 beat and such) and you can also ‘automate’ changing of that beat during the song, but it will not re-layout the measures to match that beat.
Well, and speaking of automation, LMMS is pretty cool in that regard, because you can automate anything that’s got a control in the UI. So, automation means you can have it e.g. turn up the volume at measure 53 over the course of 4 measures and stuff like that.

Ardour is definitely a lot more powerful, a lot more feature-rich. I definitely wasn’t at the point, where I could really appreciate that. It was also somewhat less stable, so it would crash every so often. Since it would dutifully restore all your work, I wouldn’t call that a deal breaker, but it can be annoying.

If only this stuff wouldn’t eat so much time. I’ve been writing a library and it often feels like I’ll spend 1 hour documenting for maybe 5 hours of implementing a feature. And I’m not even terribly happy with the documentation yet. 🫠

I feel like you severely overestimate the reach of this channel. People who watch LTT are in a very specific bubble of YouTube + PC gaming + techy-but-not-too-techy.

But ultimately, even if every average person parroted exactly what LTT says, I don’t feel like we can do much about it, even if we know about it and discuss it. The guy is just going to find some way to shoot himself in the foot for entertainment. You can do hardly anything to solve that on a technological level.

Nope, I’m glad to share.

I personalized it from the “Gruvbox Rainbow” preset from here: https://starship.rs/presets/
So, you might prefer that, if you’re not, well, me.

You will need to set up a NerdFont, like the Starship installation guide says.

Here’s my configuration:

"$schema" = 'https://starship.rs/config-schema.json'

format = """
[$status](bg:color_red fg:color_fg0)\
[](fg:color_red bg:color_orange)\
[$cmd_duration](bg:color_orange fg:color_fg0)\
[](fg:color_orange bg:color_yellow)\
[$time](bg:color_yellow fg:color_fg0)\
[](fg:color_yellow)\
$line_break\
[$directory](bg:color_aqua fg:color_fg0)\
[](fg:color_aqua bg:color_blue)\
[$git_branch\
$git_status](bg:color_blue fg:color_fg0)\
[](fg:color_blue bg:color_bg3)\
[$c\
$rust\
$golang\
$nodejs\
$php\
$java\
$kotlin\
$haskell\
$python\
$docker_context](bg:color_bg3 fg:color_fg0)\
[](fg:color_bg3)\
$line_break\
$line_break"""

palette = 'gruvbox_dark'

[palettes.gruvbox_dark]
color_fg0 = '#ffffff'
color_bg1 = '#3c3836'
color_bg3 = '#665c54'
color_blue = '#458588'
color_aqua = '#689d6a'
color_green = '#98971a'
color_orange = '#d65d0e'
color_purple = '#b16286'
color_red = '#cc241d'
color_yellow = '#d79921'

[status]
disabled = false
symbol = ""
format = ' $symbol $status '

[username]
format = ' $user '

[directory]
format = " $path "
truncation_length = 3
truncation_symbol = "…/"

[directory.substitutions]
"Documents" = "󰈙 "
"Downloads" = " "
"Music" = "󰝚 "
"Pictures" = " "
"Projects" = "󰲋 "

[git_branch]
symbol = ""
format = ' $symbol $branch '

[git_status]
style = "bg:color_aqua"
format = '$all_status$ahead_behind '

[nodejs]
symbol = ""
format = ' $symbol $version '

[c]
symbol = " "
format = ' $symbol $version '

[rust]
symbol = ""
format = ' $symbol $version '

[golang]
symbol = ""
format = ' $symbol $version '

[php]
symbol = ""
format = ' $symbol $version '

[java]
symbol = " "
format = ' $symbol $version '

[kotlin]
symbol = ""
format = ' $symbol $version '

[haskell]
symbol = ""
format = ' $symbol $version '

[python]
symbol = ""
format = ' $symbol $version '

[cmd_duration]
format = ' 󱦟 $duration '

[time]
disabled = false
time_format = "%R"
format = '  $time '

[line_break]
disabled = false

I mean, there’s some decent design principles behind it. For one, it just takes up space only once rather than for each window individually.

But much more importantly, it makes use of an implication of Fitts’s Law: https://en.wikipedia.org/wiki/Fitts’s_law#Implications_for_UI_design
TL;DR: Because you can slam your mouse cursor against the top of the screen, you can’t miss the menu vertically. It’s like an infinitely tall button. This makes it fast for users to move their cursor there.

Having said that, this macOS design is from a time when the mouse and navigation menus were the primary user interaction method, which they’re not anymore. So, yeah, that’s why it was designed like that, but I doubt they’d expend this much effort to design it like that again.

It automatically suggests commands, you’ve run before, if you start typing the first letters, like so:

You can also press the Up-Arrow at any point to show other commands from your history which contain the text that you just typed.

So, it is similar to Ctrl+R in Bash, but easier to use and you don’t have to actively think about it.

Yeah, the Y is a wildcard in that position. Typically, you would write it as an underscore, primarily because most Prolog compilers will warn about unknown variables, since those could also just be a typo of an existing variable.

Oh, when you’re coding something in a Git repo and you realize that you need to make a different change before you continue coding (e.g. switch to a branch, pull newest changes, or just create a separate smaller commit for part of your change), then you can run git stash push to put away your current changes, then make your other change, and then run git stash pop to bring your ongoing changes back. I recommend reading git stash --help, if you want to use it.

Sometimes, though, you might end up just taking it into a different direction altogether or simply forget that you had something stashed. That’s when that indicator comes in handy. Because while you can have multiple things stashed, I do find it’s best not to keep them around for too long. If you do want to keep them for longer, then you can always create a branch and commit it as WIP onto there, so that you can push it onto a remote repo.

Yep, here’s my Starship prompt, for example:

So, I have it configured to show:

• the exit code of the last command (if it’s non-zero),
• the duration of the last command (if it’s longer than 2 seconds),
• the time (when the last command ended),
• the current directory,
• the current Git branch, and it also shows some Git status information, for example the $ means I have something stashed,
• and finally the technology in use in a repository/directory, so in this case that repo uses Rust and the compiler version is 1.83.

Man, even knowing that YAML document was going to be laden with bullshit, I only spotted the unquoted version strings looking fishy.

I also really dislike how often YAML is abused to take keys as list items. Something like this, for example:

hosts:
  debian-vm:
    user: root
  database-server:
    user: sql

“debian-vm” and “database-server” are the hostname, and as such they are values. So, this should be written as:

hosts:
  - name: debian-vm
    user: root
  - name: database-server
    user: sql

And I’m not just nitpicking here. If we change the example a bit:

hosts:
  database:
    user: sql

…then suddenly, you don’t know, if “database” is just one of many possible hosts or if all hosts always have a shared database with this technology.