They are still technically open-source. I’m not saying that they’re not. But they’re actively alienating users who want to use open-source, because those users cannot get support, report bugs or contribute to the project without using proprietary software.

I’m so tired of projects being like “We’re open-source” and then they’re hosted on GitHub, using Discord and whatever fucking other awful tooling they can get their hands on. Thanks guys. I’ll definitely check out your project, yes.

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

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.

I think, a big part of the problem is that much of the cost is sunken into things that don’t really teach you too much. The basic game concept prototype can probably be developed for less than $10m. You do still learn some things by making really nice graphics. But then making those nice graphics as well as sounds, voice recordings and world design for your massive open world, that’s when you’re just doing more of the same at quite the scale.

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.

I could never get over how boring the gameplay of Infamous looked. Comparing it to a third-person shooter is pretty apt. Like, you’ve got these crazy lightning powers, but 90% of the time, you just use your hand buzzer to give folks a bit of a zap. Riveting.

There’s rumors of Bethesda working on an own Oblivion remake…

It runs in the Skyrim Special Edition engine, so should work wherever SSE works. And SSE does work in Proton under Linux.

Well, I’m talking about my team members at my dayjob. I’m a software engineer.

But it’s also a lot less explicit than what you’re probably imagining. It’s rather that we have a meeting and realize that a problem re-occurred which we thought we solved months ago. So, then everyone starts collectively scratching their head and somewhat rhetoric questions might be thrown into the room, i.e. “Oh man, do you still remember how we did that?”.

Then I might start typing the command how I think it would probably begin, often with the intention of then putting --help at the end to try to jump-start my memory. And then that’s where Fish often jumps in and tells me that I’m apparently typing the exact beginning letters of the command that we used a few months ago.
Sometimes this even happens when I have no recollection that I ran a given command before, and someone’s just generally asking how to do a certain task…

I just set Fish as the shell that my terminal emulator should launch. The actual default/system shell can stay Bash. And then, yeah, if you put Bash into the shebang, all the scripts will run with it, and you can just execute bash in your Fish shell at any point to drop into a Bash shell.

Occasionally, I’ll realize some syntax discrepancy where I’ve kind of learned it the Fish way, but because I’m only using Fish interactively, there’s really not a ton of syntax that I’m interacting with.

And yeah, ultimately I find it well worth it. In particular the history-based auto-suggestions are really useful. People will ask me what that command was again and I’ll start typing into my shell and it just pulls out exactly what I wanted in quite a lot of cases.

for the first time we have one file you can download and run on any linux (the only requirement being that the architecture matches!).
This is a pretty big boon for people who want to use fish but sometimes ssh to servers, where they might not have root access to install a package. So they can just scp a single file and it’s available.

That is really nice, damn. We often don’t have internet on the hosts we work with, so it’s really painful to try to install a distro package. But we are able to SSH into them, so I might genuinely start just pushing Fish binaries onto the hosts we work with. Fish is particularly neat for this, because its defaults are so good.

cargo is great at building things, it is very simplistic at installing them. Cargo wants everything in a few neat binaries, and that isn’t our use case. Fish has about 1200 .fish scripts (961 completions, 217 associated functions), as well as about 130 pages of documentation (as html and man pages), and the web-config tool and the man page generator (both written in python).

Yeah, we’ve run into that problem, too. The most promising approach in my opinion is cargo-xtask, which is a really sad thing to say, because that’s not a tool, it’s just a pattern of how you can use Rust to write your own build tool. I’ve been hacking away at a library to try to eliminate pain points and common pitfalls with that, and I have been looking for other repos with complex packaging needs to try to see, if my approach holds up. Sounds like I’ve just met my final boss. 🙃

Do you mean best FOSS terminal for Android? To my knowledge, there’s only really Termux.

You can backup you home-directory and add it back into the newly installed OS. Some of the more dedicated distro-hoppers will even have the home-directory on a separate partition, which they don’t overwrite during installation and rather just mount into the new OS.

The home-directory contains all your music, pictures, add-ons and portable software. It also contains your configurations under ~/.config/ and local files of applications under ~/.local/.
After you’ve reinstalled, you won’t have all the same applications installed, but once you reinstall them, they should pick up the configuration from those folders and work as you expect. Sometimes, your new distribution/installation might use different versions of that particular software, so it’s not guaranteed that everything works perfectly, but it does work pretty well.

To me, it’s a matter of:

1. Doesn’t do anything extra. openSUSE runs automated tests and reports bugs to the KDE devs before a release. They also maintain a Firefox patch to integrate it into the KDE MIME type system. Semi-decent distros will at least still package that patch and setup xdg-desktop-portal-kde by default. To my knowledge, Debian/Kubuntu/etc. do none of that.
2. Old dependencies, which sometimes cause bugs in KDE that you don’t see elsewhere. But also just old versions of KDE Plasma, even though Plasma gets better and more stable with each new release. We’ve got Kubuntu LTS at $DAYJOB, and you would not believe the number of times people mention something not quite working as they expected or wanted, and I get to respond that this would be fixed already, if we weren’t using such an ancient version…

openSUSE does the nicest KDE. It also comes with BTRFS snapshotting out of the box, so you could’ve just rolled back that broken update. Downside is that not as many apps are packaged for it.

Cinnamon didn’t necessarily want to go back (otherwise they would have built MATE), but it was created out of dissatisfaction with GNOME 3 dropping the traditional desktop metaphor.

I can’t believe, they chose Thank Goodness You’re Here for the lead image, but wrote “thank God for that” into the title.

Yeah, that frustrates me a lot, too. They almost had it right, that they need to go beyond realism to make truly good-looking games. But in practice, they say that only to show you the most boring-ass graphics known to humanity. I don’t need your pebbles to cast shadows. I can walk outside and find a pebble that casts shadows in a minute tops. Make the pebbles cast light instead, that could look cool. Or make them cast a basketball game. That’s at least something, I haven’t seen yet.