Let the apologists have a field day in the comments.
You must log in or register to comment.
Since suggestions in the comments are just words of apologists, do you have a proposal for a solution, or is this just a rant post?
All I’m getting right now is a vague idea of some Master GUI that resembles the cockpit of a commercial jet that no “average user” is ever going to try and decipher, anyway.
do you have a proposal for a solution, or is this just a rant post?
I think this post captures a commonly felt problem whether or not it is still a fair criticism.
All the settings changes should be config files. GUI is dumb Pooh.
*Laughs in CLI.
Also TOML lol
Yeah, I’ve definitely grown to like TOML, especially after spending hours trying to edit a giant (nested) YAML file…
I didn’t realize the indentation in TOML was purely aesthetic.
This
[servers] [servers.alpha] ip = "10.0.0.1" dc = "eqdc10" [servers.beta] ip = "10.0.0.2" dc = "eqdc10"equals this
[servers] [servers.alpha] ip = "10.0.0.1" dc = "eqdc10" [servers.beta] ip = "10.0.0.2" dc = "eqdc10"which equals this
{ "servers": { "alpha": { "ip": "10.0.0.1", "dc": "eqdc10" }, "beta": { "ip": "10.0.0.2", "dc": "eqdc10" } } }Once the file is big enough wouldn’t it be better to convert it to json before editing, then converting it back?
Let the computer deal with indents and all that stuff.
I love this comment. JSON is by far the format that cares the least about being human-readable or -writable, but you’re seriously proposing writing it rather than YAML. And I kind of don’t even really disagree. But a big problem with that strategy is that you won’t find documentation for how to write the configuration in JSON.
I disagree that json is not human writable. JSON is perfectly writable since it has explicit visible separations between elements.
It might look ugly but it’s perfectly readable and writeable.
Granted, I always read json after parsing it with an auto formatter. Maybe that’s why people say that json is difficult to read? It’s true that unformatted json (minified) is way worse than yaml but no one in their right mind would not format the json, specially when it’s natively supported by most code editors.
BTW, about documentation, post formatting json looks very much like a yaml, all yaml docs can be converted to json instructions if you think a little bit.
I don’t care if settings are done by GUI or terminal, I just want clear and concise descriptions for specific settings and not a condescending “go read the man pages you fucking noob”. I’ve been fucking with Linux for over a decade now; a lack of clear documentation is not my problem, and at this point is unacceptable.
I’ve been fucking with Linux for over a decade now; a lack of clear documentation is not my problem, and at this point is unacceptable.
Well seems to me that the lack of clear documentation is in fact your problem.
I mean, fucking around for a decade?!
: P
I also wish Linux used a standardized config file format.
At this point, TOML is my favorite since it basically amounts to an attempt at standardizing the
.ini/.confstyle of config “language”/files. It’s still simple enough, but pretty powerful, and was seemingly good for the Rust and Python projects to be convinced to choose it as a default…Absolutely. I was going to suggest TOML as the standardized Linux format as well.
Sounds like you’re gonna love nixos
I actually looked into it, although I didn’t like very much that the config file is actually a program and an odd language. They should have used something commonplace like JSON
Especially when the settings are named the same/similar as other apps but do different things
Just fucking comment line quickly what the fucking thing does you dickheads, or use your settings page for more than 3 things and stop hiding everything else in your fucking .YAML (also Stop using .YAML)
YAML is good for scripting services (like docker stacks), but otherwise I agree, stop using it for absolutely everything.
go read the man pages you fucking noob
And when you actually go and read the man page, it says some shit like “Some of these options are not fully documented. For an accurate description of their functionality, consult the source code”
Recursive comments
NixOS has the potential to do really well here. The Nix language has a rich enough type system to generate GUI forms for every field, and there are several projects being worked on that allow editing NixOS options from a GUI. They’re still very janky, but it’s definitely possible to get to a point where a layperson could operate them without breaking their system.
Nix is definitely where I’d bet on good GUI development, if I had to choose. I’ve had my own issues with NixOS in the past, primarily due to me simply not being able to fully grasp some of the language for configs, but I’d definitely assume that GUI editing would be much easier due to the more predictable nature of the config files.
What’s the deal with NixOS? I’ve never tried it
It’s whole deal is “declarative” system configuration. Essentially, it means if your config file is identical to someone else’s, your systems will have identical software/dependencies, and everything should, in theory, run the same, generally speaking.
So for instance, to install a package, instead of running
sudo apt install nameofpackage, I would just edit my NixOS config file to have the linepkgs.nameofpackagein it, run a command to “rebuild” my system usingsudo nixos-rebuild switch, and it would automatically be installed.That’s not the whole of it of course, but that’s just a general overview. It’s really good for if you’re running multiple systems that need the same software, because all you need to do is copy the config file over, run
sudo nixos-rebuild switch, and the systems now have identical software.Oh yeah, and you can also easily rollback. If you break anything, you can, while starting to boot NixOS, just select the previous configuration, start your system, and any changes you’d made to software/settings will just be undone. It’s great for troubleshooting.
AFAIK NixOS also has the largest number of supported packages out of any distro.
Wow! That sounds like a dream! It gives me i3wm and emacs vibes.
Desktop Environments are decoupled from the underlying system. It makes switching DEs very easy but integration sucks.
I needed to flush dns on my Ubuntu machine. I googled it found a command for an older version. But of course the underlying stuff changed since then and that command doesn’t exist anymore.
The command to flush dns on Windows has been the same for decades. On Linux half the stuff I learn is going to be obsolete in a couple of years and that knowledge can’t be carried over to other Distros because they do it differently.
I also had to manually build and install a driver for a very common realtek wifi chipset that is not even new.
This is the reason I sometimes come back to the BSDs, they just feel more coherent as a whole.
reminds me of the one time I tried to configure a proxy on fedora KDE and then realizing most apps don’t even use the inbuilt proxy settings and there are three separate ways to configure it that are only accessable via the terminal and it is pain
This could be paraphrased as “GUI for the GUI settings, non-GUI for the non-GUI settings.” It’s not surprising to me that parts of Linux that run on systems that don’t have GUIs do. It have GUI settings. I understand the frustration, but building those is more work, and more things that can break, go out of date, etc…
What if Linux presented its config files in an app like regedit? Would that be easier? I doubt it. But with complicated data structures, making a first-class app just to edit a specific text file or set of files on disk is a very low ROI for engineering hours.
Then at least give users the ability to edit said text files with a text editor… but the community fights that as well. 🙄 The only distro I ever saw that enabled users to open a file browser and, through that, a text editor as root to edit system files was Mint. KDE had it for a short while before they patched it out again as far as I know (last time I checked Dolphin outright refused to start with root privileges).
It’s not like there weren’t ways to make it easier with little investment. Some elitists just managed to suppress even those efforts for decades.
Kde allows you to edit files with elevated permissions; use Kate for that. Open any system file in Kate and it will ask you for your password when you’ll try to save it.
I think there should be a standard for config files, where it defines all of the options and possible values, so that an app can be made to modify them.
Any modern Linux distro viable for the average user uses systemd, and there ain’t many different bootloaders being used by big distros either (almost always either Grub or systemd-boot, rarely Efistub). Likewise it’s clear for years that Wayland is the future (not to mention this problem persists for over 2 decades now).
I don’t see a problem with lack of standardized config files, rather a lack of interest by the rather tech-conservative part of the Linux community (who by now often have a lot to say in development circles).
There doesn’t seem to be an existing standard for what I described, from what I see.
There are existing standards. The issue is that there are too many different standards and some programs will choose to make their conf files half standardized, half unique.
There’s INI, YAML, JSON, XML, TOML, etc.
Honestly, the Linux team needs to just choose one of these formats, declare it the gold standard, and slowly migrate the config files for most core components over to it. By declaring a standard, you’ll eventually get the developers of most major third-party tools and components to eventually migrate.
Thats not exactly what I meant, I meant a system where you would have a file that defines all the options for an app, and their possible values, so a gui or program could be made to edit them.
Yeah something like that should be doable but it would require that programs provide a schema and the OS to have a way for the programs to “announce” themselves so it can be aware of the configuration files and the schema.
I’m sure some project could create a GUI that could cover the most common applications, though.
It’s always fun trying to set up a program, learning the config syntax, running it, having it fail, and then spending an hour debugging before you realize it never even read your config changes because you were supposed to use one of the other half dozen conf files it has spread all across your drive. Is it under
/etc/,/usr/local/etc/,/opt/, or your home directory?I was thinking, they would put the definitions in a specific directory, like if its installed locally, ~/.config/definitions or if installed globally /etc/definitions and then any settings apps would search for those.
If you ignore the gui part, this sounds a lot like nixos.
What comes sort of close, is that you can define so-called “schemas”, at least for JSON, TOML, YAML and XML. Here’s what that might look like for JSON: https://json-schema.org/learn/getting-started-step-by-step
I don’t know, if you can actually generate a GUI from such a schema, though. They’re intended for validating existing data, so I don’t know, if they give you enough data to work with to actually provide a GUI. For example, you don’t really have a human-readable name in these. The fields are rather called e.g. “productName”.
Yeah, I am aware of schemas, I meant something where you would have, for example, a conf.definition.json file:
{ screenResolution: { definition: "What resolution the screen should be", options: [ "1920x1080", "720x470" ] } }So then, a settings app could control settings for other programs, like apple does, by checking this file, and editing the configuration file based on it.
Schemas are a nightmare to work with, and are totally unreadable
If you don’t know what you’re doing, you have no reason to edit those settings.
Wanting a good GUI doesn’t mean you don’t know what you are doing.
Conversely, if it was presented in a more user friendly way, perhaps more people would know what they were doing.
MY CREATOR USED LINUX TO DEVELOPE ME I FEEL COLD WHEN I EXTRACT MY DATA
*openSUSE enters the chatroom
SUSE/openSUSE are the only ones that have it figured out. It requires a lot of polish, but it’s the only distro that seems to really care about a deeper system configuration through GUI, and that’s really appreciated.
sysctl, anyone?
You should have done the 2nd half in ascii art because terminal ;)
2nd half in raw binary because I use Arch btw.
2nd half in uncompiled source code because gentoo
YaST on OpenSUSE is pretty nice.
I always viewed YaST as SMIT(ty) for linux. Haven’t looked at suse in forever, though.
I have no idea what SMIT(ty) is, so I’ll just smile and nod [smiles and nods]
https://en.wikipedia.org/wiki/System_Management_Interface_Tool
It’s a menu driven system management tool for IBM’s AIX unix variant. Oddly enough, even Wikipedia shows the relationship from SMIT to YaST. Instead of just smile and nod, next time make up something about “smitty print” (damn near everything was under the “print submenu”, ostensibly because you were printing out the config to screen), and look like you are a grizzled veteran of corporate unix from the days of yore.
:-)
