(Sorry for brainstorming, tl;dr)
If FreeBSD and Mac OS are so similar, why can't FreeBSD easily adopt many of the desktop benefits of OS X? I've always genuinely been curious about this.
The thing is that FreeBSD does *not* put its users into a corset,
does not define itself by its desktop, but by its core.
People choose FreeBSD not because of "its desktop", but for other reasons.
Both main desktop principles - Apple's strict and Microsoft's loose "desktop discipline" - are perfectly supported on FreeBSD in the way of Gnome and KDE.
The only problem is the seamless lack of the integration of FreeBSD to these desktops - all those system-dependent things, mostly of administrative nature.
To most "normal" people a computer OS is "good" when:
- common computer handling skills are sufficient to set up a working system. That is, no need to edit config files, and by no means ever the need to use something esoteric the guys call "console" or "terminal".
- the desktop is seamless. All things match the look+feel and the design guidelines of the preferred OS. No "patchwork" impression.
- no essential things of nowadays personal computers are missing, like Bluetooth, reliable suspend+resume (to RAM as well as to disk)
- the most common hardware is supported in a timely manner
This are just a few possibly very important aspects important to "normal" users.
We can learn a lot from Apple.
Much of MacOS stuff is powered by scripts hidden behind a seamlessly-integrated frontend UI.
Thus I ask myself, could it be a good idea to make a framework of system administration scripts designed for communication with a GUI frontend, like Apple did for their own use?
So that there is some sort of "API" that assists integrators to seamlessly add this stuff into desktops like Gnome, KDE etc.
An advantage of such an "API" would be that the integrators are *not* required to have deep system knowledge of every component of FreeBSD, which bars many people willing to volunteer from doing so.
Couldn't this be a sensible approach that could make integration of FreeBSD *much* easier?
Let me explain why I am thinking about these things so much.
I am currently working on a jail manager that is actually easy to use, both for beginners and professionals.
As a consequence of this I am implementing the interactive part of my utility in a manner that can be integrated easily into all those environments.
And this means that I had to include thoughts about the UI from the beginning, for those users who prefer not to use the command line.
A simple approach into the direction of frontend-independent system administration has already been done by the
dialog (1)
utility which is been used by many installers.
So it has been very simple to add a graphic installer to FreeBSD - they just added a graphical based frontend to the text-based one, without having to make much work on the backend side.
This way they needed not to write another full installer, but just quickly added an empty frontend GUI shell.
Ideally the integration would be that easy that integrators have not to do much more than creating dialogs with the actual desktop framework's (Qt, Gtk,...) dialog editors and do all the fine-tuning so that the UX is smooth, and just attach that to the scripts that do the actual work.
Currently there is much redundant work in this area.
Every single of these separated "desktop building" groups (Mate/GhostBSD, Lumina/TrueOS,...) repeats this big effort again and again.
This kind of having-to-reinvent-wheels-integration approach thus has a divisive and weakening effect on the BSD community.
Thus I believe it might be worth thinking about how this kind of redundant work could be avoided, achieving the goal of making seamlessly integrating FreeBSD into KDE, Gnome and all these DMs much easier.
But how can we achieve that this is actually BSD compatible?
Meaning that the possibility to do manual (or scripted) configuration editing does not get blocked by interactive configuration utilities that do not respect changes done to them by others (scripts, admins)?
Apple solves this problem by making the config files XML (thanks
herrbischoff for hinting at that). This way they can be edited manually too. However, this breaks much things and it is probably no much joy to edit such files.
So the correct solution would be to have a sort of parsing-lexing interface utility library so that interactive utilities can easily make changes
without clobbering the config files more than necessary.
Thus I am thinking about how the situation would be, if there exist:
- parsing-lexing routines for handling the most common types of config files (i.e. read the config into a data structure, write back changes into the config file respecting its formatting)
- script/API interfaced interactive configuration utilities that are easily integrable into different GUI frameworks
I ask myself: Would then be so much motivation (maybe even the need?) for integrators to fork to make a separate distro just to support a single DE, instead of staying in the FreeBSD project and just working on integrating the respective DE's?