Ah, that’s a shame. Thanks for the context though.

I did feel a little bit of that slight dismissal or elitism from the thread I linked above about the graphical installer ISO. Although I think the relative surge of new users after graphical ISO’s implementation did end up changing some minds on the merit of its continual development.

It seems like some tools just never fully realize their potential market demand until they’re finally implemented and consequently adopted. Quite the catch 22.

I also wonder if it’s a bit of a motivational aspect for individual contributors, as in demand with mostly originate from novice users who’ve yet to master the Nix language, yet by the time one’s gained enough experience to contribute to Snowflake OS, you’ve kind of grown out of outgrow the need for it. That kind of reflects my personal interests around graphical programming, as I became more familiar with various languages, my inkling for a graphical representation of control flow gradually waned.

Still, I think lowering the barrier to adoption is in the long run best serves the community and in sustaining new contributors. Sort of like the conventional Greek proverb:

A society grows great when old men plant trees whose shade they know they shall never sit in.

Nix can create attribute sets from JSON, so there isn’t a need to generate nix code.

Is there a good way of mixing and mashing JSON attribute sets with conventional nix config files? Perhaps relegating some config to machine-generated JSON, and some hand crafted configs?

As a prior proponent of graphical programming interfaces, I’ve been thinking there’d be a good use case for a GUI based control panel for NixOS, something that could transcompile standard user selected options down to a nix config that could be abstract of the way from most users, like any sort of game save file.

Given all options and packages in nixpkgs are already machine readable and indexed, supplying a GUI based tool to procedurally generate nix codes doesn’t at first seem initially daunting, but given the past discussions around this idea perhaps proves it to be on the contrary:

• https://discourse.nixos.org/t/is-anyone-working-on-a-gui-tool-to-manage-packages/5540
• https://discourse.nixos.org/t/wondering-about-nix/32919/5
• https://github.com/nix-gui/nix-gui
• https://discourse.nixos.org/t/negativity-around-the-graphical-installer/67646/12

Although SnowflakeOS in particular looks promising:

SnowflakeOS Simple, Immutable, Reproducible SnowflakeOS is a NixOS based Linux distribution focused on beginner friendliness and ease of use.

https://snowflakeos.org/

Mainly the official git CLI for controlling branches and sub modules, and sometimes the GitHub CLI if quickly checking out a pull request from a forked repo.

Also use the source control tab in VSCode rather often, as it’s really convenient to review and stage individual line changes from its diff view, and writing commit messages with a spell check extension.

If it’s a big diff or merge conflict, I’ll break out the big guns like Meld, which has better visualizations for comparing file trees and directories.

About a decade ago, I used to use SmartGit, then tried GitKraken when that came around, but never really use much of the bells and whistles and wasn’t keen on subscription pricing. Especially as the UX for GitHub and other code hosting platforms online have matured.

What user software are folks using to monitor and log PSU sensor data?

Would be nice to correlate power usage and efficiency with system load percentage over time and type (CPU vs GPU).

I hope this rust library can make its way back into Moonlight and Sunshine projects.

I’m waiting on support for inserting PDF figures, the most common format my tools export.

• https://github.com/typst/typst/issues/145

What about carrying on a legacy with maintaining a intergenerational codebases? Like from a family owned business, a FOSS project, or hobby video game? Something that span’s across tech stacks, historic trends, and familial code authors, like the ship of Theseus crossed with Noah’s Ark (built with the help of Noah’s entire family over almost 100 years, as the theological mythology goes).

You know how folks inherit tools, workshops, or auto projects from parents and family? Stuff like wood working equipment, sewing machines, or whatever tools of the trade. It’s got me wondering, what’s it like for children that inherit their parents’ codebase, computers, keyboards. Surely with the growth of the tech sector and job market, compared to half a century prior, this could be a growing re-occurrence.

E.g. like the entire premise of this YouTube channel titled “Inheritance Machining”: https://youtu.be/hearLttbrLo

For example, my grandfather worked for IBM, and my family recalls growing up surrounded by punch cards around the house. Of course that form of programming only lasted so long, so the next generation was unlikely to reuse the same tools of the trade, but as tech stacks have matured and interfaces standardized, what are the chances are that folk’s children will use the same Linux kernel modules, custom mechanical keyboards or desktop chassis that their parents used today?