arran 🇦🇺

Linux is a kernel, but people often refer to the whole thing as linux…

Everything else is independent free software, which without a distribution you would have to source yourself, configure, and install. Plus provide small programs / scripts to glue everything together. This same software can run on other operating systems depending on what it is. Unlike Mac and Windows, these are often by one vendor and highly integrated, less so with other operating systems.

KDE and Gnome, are desktop environments which are suites of applications, including a “window manager” which is the thing which draws borders, and allows you to minimize and maximize. Typically this is what non technical users think an “operating system is”

Distributions are highly varied in terms of the glue, and updates they provide. The idea is they keep up to date on the software and take responsibility (most of the time) for integrating it and ensuring that the configuration works.

RoG adds a lot of content which makes the early game a bit easier, and opens up a lot of possibilities later.

The other expansions are only worth it once you have “completed” RoG.

I’ve definitely moved back to desktops. Still have my laptops but I use them in limited cases.

Isn’t that the plot to Mirror’s Edge?

I"m not entirely sure on the pdf / epub use case, is that for RSS contents, or RSS referred contents? If it’s referred contents then perhaps use something like Omnivore or a script/plugin.

I suspect you might be mixing something that’s better done as two different apps into one. Omnivore and similar tools you would probably want an integration for a “read later” tool.

If it’s the RSS contents you might need to use a script or plugin in an existing tool, or just write something.

In terms of desktop RSS readers I like, RSSGuard, but currently using Akgregator.

Miniflux IIRC has integrations for sending things to “read later” tools like “Omnivore” but not many.

You might find something like mailbrew useful, but if you do perhaps a “send to email” is all you needed?

You could also publish content directly to imap and use the phone’s mail client which stores things offline too. (You don’t need a full setup for imap.)

But I think distro hopping is a great idea if you have the machines / time.

Gentoo user here. It can be great for dev as you have everything that is required to build the software you’re running assuming you’re trying to produce something using the same base. Ie C++ with Qt for KDE etc.

It’s also a lot easier to build your own repo and packages with than any dev setup I’ve seen, it’s literally just a text file.

It does take a while to compile. However you need opinions to use it… Otherwise you will just have useflags enabled on everything. It does require a bit of understanding of how linux is built but the guide does most of the work for you, and it’s easy to install on an existing system. If you’re using btrfs you can install it on a subvolume and try it out easy.

However I used it during the 00s and 20s… But not the 10s. The difference is that software is moving way too fast for distributions to keep up with, so you will definitely want to build your own ebuilds at some point. Emerge / portage can sometimes cause issues upgrading too. But nothing a btrfs snapshot can’t save you from.

I feel like there is some cause to list CS degrees and their position on Unix and Linux. awesome-linux-cs repo?

Moved from Gentoo to Ubuntu in 2008 as I needed to focus more on my job, moved back to Gentoo in 2022. Snaps were part of it, but really the lack of maintenance and vision around the apt repository was really the issue. More and more I was installing stray debs, or having to use flatpaks / AppImages for what what I wanted the system to manage for me.

Not that I’ve entirely stopped using flatpaks or AppImages, but the process of creating an ebuild is far simpler than trying to do anything with a deb. For a while I had hope about the ppa, however that became fewer and fewer. I do think that the battle to have a comprehensive software repository is a loosing one because of the way things are currently structured.

Something like: https://forums.gentoo.org/viewtopic-t-147062-start-0.html

Used to use Xnest to do this. IDK how easy it still is these days.

Agreed

Knoppix got Ubuntu halfway there.

Is it Space Odyssey?

The fact that is is from LA Times shows that it’s still significant though

As in part of a review process?

Things like:

• Software update process
• Installing software which isn’t in a repository
• Seeing how the community is for support ?

Back before the media decided it wasn’t a competitor but rather a potential profit source. I do think the government does need to have it’s own alternatives (obviously not identical more on this one day) for other reasons, such as for it’s own media releases, but more internationally coordinated appropriate & considered legislation is probably better.

This. Although I’m not sure if it’s about in-app display, but it needs to be on the store and on a website somewhere.

I asked chatgpt to write a go program for this, this looks roughly correct (I have used both libraries before) obviously this won’t be enough for your particular use case. I imagine you can integrate an RSS feed to your site, however if you’re using something like hugo perhaps output it as a csv.

Super low effort but a good start I think:

package main

import (
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	git "github.com/go-git/go-git/v5"
	rss "github.com/jteeuwen/go-pkg-rss"
)

const (
	timeout = 5 // timeout in seconds for the RSS feed generation
)

// Repository represents a git repository with its URL
type Repository struct {
	URL string
}

// Repositories is the list of git repositories
var Repositories = []Repository{
	{URL: "https://github.com/owner/repo1"},
	{URL: "https://github.com/owner/repo2"},
	// Add more repositories here
}

// FetchLatestTag fetches the latest tag from a git repository
func FetchLatestTag(repoURL string) (string, string, error) {
	// Clone the repository to a temporary directory
	dir, err := os.MkdirTemp("", "repo")
	if err != nil {
		return "", "", err
	}
	defer os.RemoveAll(dir)

	_, err = git.PlainClone(dir, true, &git.CloneOptions{
		URL:      repoURL,
		Progress: os.Stdout,
	})
	if err != nil {
		return "", "", err
	}

	repo, err := git.PlainOpen(dir)
	if err != nil {
		return "", "", err
	}

	tags, err := repo.Tags()
	if err != nil {
		return "", "", err
	}

	var latestTag string
	var latestCommitTime time.Time

	err = tags.ForEach(func(ref *plumbing.Reference) error {
		tag := ref.Name().Short()
		commit, err := repo.CommitObject(ref.Hash())
		if err != nil {
			return err
		}
		if commit.Committer.When.After(latestCommitTime) {
			latestCommitTime = commit.Committer.When
			latestTag = tag
		}
		return nil
	})
	if err != nil {
		return "", "", err
	}

	return latestTag, latestCommitTime.Format(time.RFC1123Z), nil
}

// GenerateRSS generates an RSS feed from the latest tags of the repositories
func GenerateRSS() string {
	feed := rss.Feed{
		Title:       "Latest Tags from Git Repositories",
		Link:        &rss.Link{Href: "http://example.com/"},
		Description: "This feed provides the latest tags from a list of git repositories.",
		Created:     time.Now(),
	}

	for _, repo := range Repositories {
		tag, date, err := FetchLatestTag(repo.URL)
		if err != nil {
			log.Printf("Error fetching latest tag for repository %s: %v", repo.URL, err)
			continue
		}
		feed.Items = append(feed.Items, &rss.Item{
			Title:       fmt.Sprintf("Latest tag for %s: %s", repo.URL, tag),
			Link:        &rss.Link{Href: repo.URL},
			Description: fmt.Sprintf("The latest tag for repository %s is %s, created on %s.", repo.URL, tag, date),
			Created:     time.Now(),
		})
	}

	var rssFeed strings.Builder
	rssFeed.WriteString(xml.Header)
	if err := feed.Write(&rssFeed); err != nil {
		log.Fatalf("Error generating RSS feed: %v", err)
	}

	return rssFeed.String()
}

func main() {
	rssFeed := GenerateRSS()
	fmt.Println(rssFeed)
}

Thanks