Or you could just use a window manager that doesn’t change? I’ve had the same desktop env for over a decade and nothing has changed at all. In contrast with windows and osx where we literally cannot opt out.
I entirely understand alxlaz's position, buy my solution was exactly sticking to better window managers (in terms of long term support). My workstation is Linux since '98 or '99, and since then I've used GNUstep for about a decade, then i3 and now sway (basically i3 for Wayland). I'm free from the breaking changes alxlaz describes.
I just checked, and GNUstep is pretty much alive. Even that change was caused by me wanting to try tiling window managers, not support failure.
Ah, I'm in a similar-ish boat, I use WindowMaker :). This isolates me from most, but definitely not all dubious changes. I've been down the tiling WM rabbit hole a while ago but it's just not for me, I like the mouse, I like icons...
It's a little unsettling that there are two ways to get a stable experience: using window manager from 1998 (OK, ok, WindowMaker is still maintained-ish, in fact a very tiny portion of the code written after 1998 is mine :-) ), or getting used to a workflow akin to that of Windows 1.01 (i.e. a tiling WM).
On the bright side, though, yeah, at least we have a choice!
KDE 4 was released in 2008 and has been stable and consistent for more than a decade. That predates Windows 7. So in the same time KDE has been consistent you’ve had had the migration from XP or Vista to Win7. Then Windows 8 and now Windows 10. They’ve all bought massive changes in the UI experience.
If you don’t like KDE then use LXCE or Enlightenment or any of the other Linux desktop environments that have been pretty static (and have been even longer than KDE).
So yeah, there actually is a lot of choice on Linux and not all of it looks dated.
Mate desktop has been fairly stable (the default green tinted icon set is gross but fixable). I switched to it after Ubuntu long term support, and Debian on my other computer dropped gnome 2. Just didn't like gnome 3 or unity. Cinnamon was okay but at the time was still coupled to the brain dead ideas the gnome team had been perusing at the time. I haven't checked it out recently enough to know if it had improved.
> (...) getting used to a workflow akin to that of Windows 1.01 (i.e. a tiling WM)
Not really, unless it's a tong-in-cheek remark. Tiling window managers use virtual desktops and programmable positioning of windows to produce a predictable layout. Windows 1.01 had neither of those.
Add muscle memory to it and, if you can endure the learning/customization curve, you get a very efficient window manager. Whenever I'm alt-tabbing in search of windows in Windows or OSX I feel I'm using old software.
It's tongue-in-cheek of course :). That being said, I did find tiling WMs to be very unwieldy on most screens. When I first went down the tiling WM rabbit hole, I was using a laptop with a 15" screen, and that was great. After a while I got a 27" monitor, though, and tiling became extremely annoying -- every window is now either too wide to be read comfortably and I end up padding the screen with useless xterms, or too small for contents to fit in any reasonable way.
Tiling window managers are a great way to fiddle with window arrangement LESS not more. Shoving terminal windows between other windows for spacing is spacebar heating. I3 has a branch with the feature required its called i3-gaps. This feature is on its way to becoming a part of mainline i3 but has been available for about 11 years now as a separate package.
Would give you a configurable empty border only when you have a singular window ensuring that the single window isn't so large as to be hard to read comfortably.
As far as windows being too small to read comfortably I'd advise you to place no more than 2-3 windows per workspace. For the benefit of those who don't use i3 workspaces are per monitor.
Given 2 monitors you can easily show 4-6 windows which is easily enough context for about any task.
So, like I said in my other reply: this was back when i3-gaps was pretty fresh. I don't recall the inverse_outer outer setting, and looking at the github repository, it looks like it was merged in 2018. I'm talking about something that happened like ten years ago :-).
As for this part:
> As far as windows being too small to read comfortably I'd advise you to place no more than 2-3 windows per workspace. For the benefit of those who don't use i3 workspaces are per monitor.
Yeah, this is pretty much where the fiddling comes from.
I don't want to use 2-3 windows per workspace. I sometimes have to work on a piece of code and have 8-10 PDFs open for it -- datasheets, reference guides, schematics and whatnot, at which I want to be able to look from time to time. Sometimes while I'm also looking at the code, sometimes in full-screen (because I'm looking at a big diagram). Sometimes I need to look at a part of a diagram while I'm looking at the code. So I need them to be in the same view as the code. All in all -- including specs, standards, the code window(s), a few xterms -- I easily have 12-15 windows open in order to work on one thing, and it's not really optional.
i3's tabbed view is sort of what I wanted for the PDFs but it's annoying that, if you want to switch to the right one using nothing but the keyboard, you have to go through all of them. You go back and forth, not to the Nth tab (or at least you couldn't back when I tried i3).
That's actually what I liked about ratpoison. Instead of trying to be smart, it just let me multiplex my screen, which is what I really wanted.
I could sort of bend my workflow around all this and, through a complicated set of chords, make use of the whole thing in a productive manner. However, it was anything but convenient. I'm way happier with a floating WM and do a lot less fiddling with the windows.
With herbstluftwm I address that issue by just doing a split; you don't necessarily need to put anything in a given pane, so it's possible to just resize the pane for the window about which you actually care, and ignore the unused space entirely.
Of course, I typically end up sticking a terminal or editor or chat window or music player or something in there anyway, because why not?
> How are useless xterms different from uselessly used space for a simply centered window?
You still have to open them and move them around, especially if you do change your layout eventually.
I actually didn't have that problem when I was using ratpoison, but some applications (looking at you, Eclipse...) don't really work with it. (I know about stumpwm, and I do know Common Lisp, but alas, we just don't get along too well). When I moved to i3, which is greedy with screen space, I actually wrote myself a couple of scripts to handle this situation "gracefully" (automatically pad the screen with empty X11 windows, automatically un-pad them when needed) and bound them to a couple of key combinations.
I mean it sort of worked but at one point I decided I want to spend more time doing fun/useful things and less time hacking on my window manager.
Almost all my Linux work has been via command line for quite a while, so maybe this has changed, but my recollection was the GUI inconsistency had little to do with the window manager. It had much more to do with the X libraries that the developer of each app decided to use.
I used to have a screen shot showing me running something like 5 different GUI apps on a Linux system, all of them trying to open a file, each with a completely different file chooser dialog. That's because one app used Motif, one use GTK, one used Qt, and I have no idea what the others used.
Nice. Actually some of these remind me of Windows, too. It's less common on Windows but plenty of applications seem to link against antiquated libraries which provide really unusable and nonstandard file selection dialogs. One thing I remember being annoyed with is old-style ones that are very small and you can't resize. Here are some, but I've seen weirder ones:
With sandboxing, macOS is now forcing devs to use their file selection dialog because it will grant access to the selected files - a custom dialog box has no such blessing.
It's nice, actually; it's finally making the file selection process feel uniform. Too many Java apps are still using random Swing dialogs though...
Sandboxed Java apps don’t. Here I’m talking about apps that you can’t get on the App Store, many of which are older Java programs which haven’t been updated to use the newer APIs.
The push to force sandboxed apps to use the system dialog had the nice side effect of forcing many GUI APIs to actually use the native file pickers, which meant that a lot of non-app-store apps started to use the native file picker. But Java apps don’t automatically get that upgrade.
>I used to have a screen shot showing me running something like 5 different GUI apps on a Linux system, all of them trying to open a file, each with a completely different file chooser dialog. That's because one app used Motif, one use GTK, one used Qt, and I have no idea what the others used.
But they all perform the same function of choosing a file right? What does it matter if they all look the same? I don't understand why anyone would care so much whether the file choosing windows match eachother visually between different apps. As long as I can pick a file effectively, I wouldn't really care if the app had pink sparkles or something. As long as it does what it's supposed to.
The aesthetics are not a completely invalid consideration. People recognize patterns and find choosing behaviors/reactions easier when recognizing a common pattern. It takes more effort to respond to unfamiliar stimulus. Aesthetics aren't the only consideration though.
File choosers typically allow one to bookmark commonly used directories unfortunately this is per chooser purely for reasons of lack of coordination.
Further despite people asking for it for the last 15 years the gtk version doesn't have a very good way to visually pick out an image in their picker. To date the only good way to pick out an image in a gtk app even GIMP is to open a file manager alongside the application and drag the file into the application or file chooser.
I find it unlikely that most people figure this out.
The devil is in the implementation details. Are favorites/shortcuts in the same part of the screen? Are they in the same order? Does the dialog remember sort and view configuration between folders? Does the dialog differentiate between mounts, symlinks, and tangible files? Does it display networked machines properly? Are file icons consistent in design if not color scheme? The problem most people have (in my experience) is behavioral. The mismatching visuals is just the most jarring aspect that's easiest to point to.
It's not that there are aesthetic difference like pink sparkles on some.
It's that some have a file type filter and some don't. Some show all files while others hide dotfiles and provide a checkbox to show them. Some show files and directories in the same pane while others show directories in one pane and files in another. Some show ".." in their directory list and you go up by opening that, others do not show ".." and provide a button for going up.
I understand this, but modularity is one of the philosophies and benefits behind linux, with modularity unfortunately comes inconsistency. As many of the apps available on linux are open source and open source developers are mostly free to use whatever toolkits they want or are comfortable with, you're not likely to get the consistency you want with linux.
With windows you have an API provided by windows for ui programs, there will be more consistency between apps because of this.
Linux providing a standardized ui API would go against the core philosophy of it and you're not likely going to be able to convince every developer making gui apps for linux to agree on and use only one graphical toolkit.
Like with anything, every os has tradeoffs and downsides, personally I prefer modularity and control over my system to ui consistency.
A standard API can provide more modularity and control than the current approach.
You do this by having several available implementations of the API as dynamic libraries--one using Motif, one using GTK, one using Qt, and so on.
There would be a per user config setting specifying which implementation the user prefers. If a program wants to put up a file chooser, it can read that, then load the right library and use the API. A program might also have per program settings to override that, to handle the case where a user really does prefer, say, GTK file choosers for most programs but Qt file choosers for some specific programs.
This gives you more UI consistency, makes things more modular than having every program include file chooser dialog code, and gives more control to the user, and doesn't interfere with the developer choosing whatever toolkit they prefer for things other than standard dialogs.
>You do this by having several available implementations of the API as dynamic libraries--one using Motif, one using GTK, one using Qt, and so on.
OK, now who's going to do this? At what level would this be implemented at? Would this be at the windows server level? Would I have to pull in GtK, motif, qt and every other library that this API will rely on just to install Wayland or xorg? Will it be at the window manager level? Will I need to pull in GfK, qt, motif etc. for every desktop environment and window manager relying on this API? Which versions of these libraries will this API rely on?
The last graphical app i wrote, I used dlangui for a GUI, should I have been forced to use Gtk or qt despite them being heavier and more complicated than what I needed?
Your program in dlangui would do something like this (but in D rather than the C-like pseudocode I'm going to use...). At the place where you want to put up a file chooser dialog, which now presumably does something like this:
char * result = dlangui_choose_file(...)
you would do this instead:
char * result = 0;
char * (*standard_choose)() = get_standard_choose();
if (standard_choose)
result = (*standard_choose)(...);
if (result == 0)
result = dlangui_choose_file(...)
get_standard_choose is a small function that would:
1. Check a standard set of configuration locations to see if the system administrator or user has configured a standard file choose dialog [1].
2. If a standard file choose dialog has been configured, the configuration information includes the path to a library that implements it. get_standard_choose() loads that library, gets a pointer to the standard_choose() functions from it, and returns that pointer.
3. get_standard_choose() returns 0 if no standard choose dialog is configured or it runs into problems trying to load it.
If the user wants GTK or Qt file chooser dialogs instead of dlangui file chooser dialogs, you don't have to use GTK or Qt. The user installs a GTK or Qt file chooser library and points to it in their standard dialog configuration.
(I'd expect at some point that toolkits like dlangui would incorporate get_standard_choose() functionality themselves. After that, you'd then just
write
char * result = dlangui_choose_file(...)
and it would deal with using the user preferred dialog if available. It would be completely transparent to the programmer using dlangui).
Same idea for other common dialogs, like color picking, printing, and font selection.
[1] Probably something like check an environment variable first. If it doesn't find a match there, probably then a config file in $XDG_CONFIG_HOME. If no match, then something in /etc.
Actual modularity would imply a common way to plug in different file choosers so you could use file mangager A with desktop b with application from desktop c.
Inconsistency comes not from modularity but rather from incompetence.
Windows has this same problem, with 3rd party and its own apps. I don't know why it needs 3 different file open dialogs, and it confuses the crap out of normies. Don't even ask me about people getting upset about not knowing when to click or double-click.
You could, but the fact that (one of) the default mainstream DE does not respect its users' workflows is a valid gripe. Going against the grain requires energy investment and it's not sure tomorrow we will still be able to run Xfce. That and e.g. systemd's changes which make one use case easy and everything else impossible, everyone but red hat be damned, leave a bad taste in my mouth - most recently homed not supporting remote login. There has been a push for projects to adopt a Code of Conduct to make sure the maintainers act with respect towards all contributors. Maybe the CoC should also include "do not yeehaw into the codebase", because I am getting tired of cowboys tripping me up and accepting no responsibility.
I do, but that doesn't help much. I don't really have a choice about GTK applications, for example -- I'm going to get the GTK 3 open file dialog and the colour picker with every GTK 3 application.
