I mean, yeah, this shouldn’t be seen as an announcement or whatever, but rather as a thing to discuss and potentially get involved in. KDE is a community project after all.

I mean, I do like the idea, but syncing such a database file is by far the smallest challenge about this (and could be easily achieved today with e.g. Syncthing or Rsync).

The far harder part is getting RSS readers to support the same file format. There is actually a small project (by basically a singular guy), which tries to accomplish this: https://github.com/39aldo39/DecSync
The desktop RSS reader it supports is GTK, though.

Somewhat of a technologically simpler solution might be to self-host FreshRSS.
Unfortunately, it is of course less simple to actually use, unless you have a home server and some sysadmin skills…

Well, I have it bound to Super+X, but you could do any of those. I just create a .desktop file for it and then it can be used like a normal application. And well, it is intentionally built so you don’t have to pass command-line flags or see the command output for creating the file.

So, this is the program I use: https://codeberg.org/trem/jot
It has basically three larger features, which is adding a file, removing empty files (because you sometimes might end up creating a file, but not using it) and then searching through empty files.
Honestly, none of these are particularly difficult to throw together in a Bash script yourself, if you don’t feel like using a random program off the internet.

Basically, for adding a file, this is a crappy version of it:

data_dir="$HOME/.local/share/notes"
mkdir -p $data_dir
date=$(date +%s)
file_name="$data_dir/${date}.md"
touch $file_name
xdg-open $file_name

And for searching through the created files, grep -iR -C2 $data_dir is virtually just as good, too. 🫠

Hmm, if I understand you correctly, this is about Windows blocking access to files while they’re being accessed by other processes. Kate is primarily built for Linux where this would not be a problem to begin with, so it is well-possible that it does not handle this gracefully.

But it does actually keep its own buffer for files. By default, you have to actively click in the UI before it will load the changes from the file. It does watch the file for file changes, but I don’t think, it has to keep the file open for that, since there’s kernel APIs to be notified for file changes on all mainstream operating systems these days.

So, uh, TL;DR: I don’t actually know, but I’m somewhat optimistic. 🫠

I have a tiny program/script that creates a file in a folder underneath ~/.local/share with basically just a timestamp in the file name and then it opens it in Kate. Certainly somewhat of a workaround, but it works quite well for me.

I can understand the sentiment and would 100% agree for programming languages.
But personally I actually like that it encourages a flat structure, because you do not want to be yakshaving the structure of your config file. Too much nesting means you will sooner or later run into configuration keys being nested under the wrong category, because your project context changed over time.

And well, as I’ve argued in a few other comments already, I think non-techie users have a disproportionally simpler time when no nesting is used. They understand the concept of a heading and then just adding a line underneath the appropriate heading is really intuitive.
You can just tell them to add the line certificate="/tmp/cert.crt" under [network.tls] and they will find a line in their config file which actually reads [network.tls] and they can just paste that line as-is.

With nesting, they’d need to add it under here:

network: {
    tls: {
        certificate: "/tmp/cert.crt"
    }
}

Which means:

• You need some awkward explanation where they should nest it, or an explanation that e.g. “network.tls” translates to nesting.
• They will ask whether they should indent the line you sent them.
• Well, and it’s also surprisingly difficult to explain between which braces they should put the text, and that’s at the end of the braces, but not after the braces etc., if you’re talking to them on a call.

It’s not even that I’m completely enamored with TOML, but this aspect is certainly growing on me…

I’m always surprised to hear people believe in ghosts, not because I consider it particularly ridiculous, but rather because ghosts have no relevance in my life. I don’t need them to exist to explain what’s happening around me.

Every few years or so, I might hear a noise where I don’t have an explanation, but that always feels adequately explained by me not knowing things. I’m constantly surrounded by living beings as well as materials that are subject to gravity, temperature, humidity etc.. Occasionally, they’ll make noises quite naturally.

Their point is that one could come up with a billion hypotheticals for what might theoretically exist, because we cannot disprove it. If we spent as much time humming and hawing whether each one actually does exist as we do for ghosts, souls, gods, Big Foot etc., then you won’t be doing anything else in life.
That’s why it’s a typical position to just say that they don’t exist until proven otherwise.

Or in the more general sense, this is Occam’s Razor: If there’s multiple possible explanations for something, then one should assume the simplest explanation until proven otherwise.
And if you hear a door slamming shut in your house, then wind is a much simpler explanation than ghosts.

VSCode is Electron, i.e. a webpage, so it’s not hugely surprising that they opted for the natively supported JavaScript Object Notation. And also shows that they don’t care for using the right tool for the job to begin with.

Personally, I much prefer TOML over YAML, because it does not have significant whitespace, and because you can read the spec in a reasonable amount of time. It just has so much less complexity, while still covering the vast majority of use-cases perfectly well.

We just document that this is how you write the config file:

[network]
bind.host = "127.0.0.1"
bind.port = 1234

# etc.

And that seems straightforward enough. Yeah, technically users can opt to use inline tables or raw strings or whatever, but they don’t have to.

Well, you can still decide how much of the TOML features you actually use in your specific application. For example, I’m currently involved in two projects at $DAYJOB where we read TOML configurations and we don’t make use of the inline tables that OP memes about in either of them.

Ultimately, the big advantage of TOML over INI is that it standardizes all kinds of small INI extensions that folks have come up with over the decades. As such, it has a formal specification and in particular only one specification.
You can assume that you can read the same TOML file from two different programming languages, which you cannot just assume for INI.

I would try to avoid driving over them when safely possible, because they make an annoying noise, which I wanted to spare folks living nearby from. ¯\_(ツ)_/¯

Counterpoints:

• TOML is intended for configuration, not for data serialization, so you shouldn’t be sending it over the wire in all too crazy ways anyways.
• Most protocols will have a built-in way of knowing when the whole content has been transferred, typically by putting a content length into the header.
• Having to wait until the closing } or ] can also be a disadvantage of JSON, since you cannot stream it, i.e. start processing the fields/elements before the whole thing has arrived. (You probably still don’t want to use TOML for that, though. JSONL, CSV or such are a better idea.)

Well, TOML is essentially just an extension of the INI format (which helped its adoption quite a bit, since you could just fork INI parsers for all kinds of programming languages).

And then, yeah, flattening everything is kind of baked into INI, where it arguably made more sense.
Although, I do also feel like non-techies fare better with flat files, since they don’t have to understand where into the structure they have to insert the value. They just need find the right “heading” to put the line under, which is something they’re familiar with.

They serve largely different use-cases. JSON is good for serializing data. TOML is good for configuration.

It’s kind of bad for scripts, where it can be either annoying or genuinely problematic, when your script hangs on a password prompt. You typically do want it to just fail right away, because if you have monitoring, then you’ll be able to spot it failing.

These days, it is (largely reliably) possible to detect whether a command is being run interactively or as part of an unattended script, so you do see some commands that trigger a sudo password prompt only for interactive use, for example systemctl does this. But this adds quite a bit of complexity to each individual program, so it isn’t really something that’s going to be implemented universally.

I also have to say that systemctl kind of gets on my tits when it does that, because it throws up a GUI dialog for grabbing the password, which is quite jarring.

Yeah, I was gonna specifically pick out biology. Feels like the more you know about it, the cooler it gets to just head outside and look at critters. Kind of like Pokémon, but real.

I would guess that the units used in smoke alarms and microwaves generally have integrated drivers that only operate at a single frequency.

Yeah, you could more easily create a rhythm than a full melody. If you get a few devices, which beep at different frequencies each, you could do a lot more by having them beep in succession and in intervals.

Of course, this requires that they’re roughly in tune, which may not be the case at all. 🥴

Most developers I’ve looked at would happily just paste the curl|bash thing into the terminal.

I mean, I typically see it used for installing applications, and so long as TLS is used for the download, I’m still not aware of a good reason why you should check the Bash script in particular in that case, since the application itself could just as well be malware.

Of course, it’s better to check the Bash script than to not check it, but at that point we should also advise to download the source code for the application, review it and then compile it yourself.
At some point, you just have to bite the bullet and I have not yet seen a good argument why the Bash script deserves special treatment here…

Having said that, for cases where you’re not installing an application, yeah, reviewing the script allows you to use it, without having to trust the source to the same degree as you do for installing an application.

Is it? I work in tech and I would have not a single fucking clue…