davvid

No, Git is alive and well. Git is under active development and continual iterative improvement.

Github might be on the decline, but git != github

git-difftool is quite helpful, especially if you want an easy way to integrate existing file-based diff tools.

Nor Catmull, unfortunately. FWIW, the article is centered around the financing and IPO side of the story.

We did not want to spend time maintaining a backward compatible parser or doing code archaeology. So this option was discarded.

Considering all of the effort and hoop-jumping involved in the route that was chosen, perhaps this decision might be worth revisiting.

In hindsight, maintaining a parser might be easier and more maintainable when compared to the current problems that were overcome and the future problems that will arise if/when the systemd libraries decide to change their C API interfaces.

One benefit of a freestanding parser is that it could be made into a reusable library that others can use and help maintain.

The "official" repo is the gitlab repo[1], but the github mirror has more watchers/stars.

[1] http://gitlab.com/garden-rs/garden

If you're into multi-repo setups then you might be interested in garden. I built this specifically for handling dozens of repos as single units.

https://github.com/garden-rs/garden

    > I had to get my project to emit compile_commands.json,
    > get clangd, figure out which things about our build
    > process clangd was not understanding from 
    > compile_commands.json and add them in .clangd

I haven't used clangd myself, though, so I can't say either way, I just know ccls works well.

By convention I tend to have the generated build system in build/ at the top-level of the repo so that the file is at build/compile_commands.json. That, or I'll arrange to have a symlink there pointing to one generated elsewhere.

The nvim snippet I use in my init.lua to setup ccls to work in that scenario is:

    vim.lsp.config('ccls', {
        init_options = {
            compilationDatabaseDirectory = 'build',
        },
    })
    vim.lsp.enable('ccls')

upon further thought, I don't like having to move my hand to the arrow keys

ctrl-n and ctrl-p should let you select next and previous from the autocomplete menu while avoiding the arrow keys.

Throughout all of this, Horse News was the only stable work I had.

Only a good writer, that truly enjoys their craft, is able to masterfully insert a witty dry pun like that into their work. Bravo!

The article didn't mention Python's atomic refcounts. They're very bad for cache usage as they're constantly invalidating cache.

It's 2025 and the closest I can find is a dictation app on my newest phone that uses online AI service, yet it's still not that great [...]

Is there anything equally effective for any of you nowadays?

I'm not affiliated in any way. You might be interested in the "Futo Keyboard" and voice input apps - they run completely offline and respect your privacy.

The source code is open and it does a good job at punctuation without you needing to prompt it by saying, "comma," or, "question mark," unlike other voice input apps such as Google's gboard.

https://keyboard.futo.org/

In case you didn't know: `git rebase --update-refs` or to make this the default behavior: `git config --global rebase.updateRefs true`.

These are called stacked branches in git. You're possibly looking for:

    git rebase --update-refs

Likewise, it's better to optimize for experienced readers than it is to optimize for students.

This post misses the IMO best indentation scheme for lisp [...]

Likewise, a lispier(?) and more compact compromise?:

    (define (match:element variable restrictions)
        (define (ok? datum)
            (every 
                (lambda (restriction)
                    (restriction datum))
                restrictions))
        (define (element-match data dictionary succeed)
            (and 
                (ok? data)
                (let ((vcell (match:lookup variable dictionary)))
                    (if vcell
                        (and 
                            (equal? (match:value vcell) data)
                            (succeed dictionary))
                        (succeed (match:bind variable data dictionary))))))
        element-match)

Here is a truly brilliant game. It's Google Bard vs. Chat GPT. Hilarity ensues.

https://www.youtube.com/watch?v=FojyYKU58cw

Qt5 to Qt6 is nothing like Python2 to Python3.

The lessons from (Qt3 to Qt4 and) Qt4 to Qt5 have been learned and moving a large project from Qt5 to Qt6 is not that hard comparatively. There are a few minor deprecated APIs to handle and it's relatively easy over all.

I even have a stable project that is compatible with Qt5 and Qt6 [1] all in a single code base (particularly thanks to the effort of the qtpy[2] library). It's not that hard, and my opinion includes C++ in that assessment.

[1] https://github.com/git-cola/git-cola/

[2] https://github.com/spyder-ide/qtpy

While I mostly wrote `mutuple` for fun, it's also a proof of concept for solving a tricky pickling problem in the jsonpickle[1] library: restoring object graphs that contain tuples with back-references to the same tuple.

I'm pretty sure there are better ways of handling this edge case, but, hey, it works and was a pretty fun experiment.

[1] https://github.com/jsonpickle/jsonpickle/pull/491

If you're into this kinda thing and are in python land you might also appreciate my friend's project in a similar vein

https://github.com/ugtar/pg_temp

Thanks for the feedback on the animations. I didn't want to keep too large of a .gif in the repo but that's the only format that's straightforward enough to have displayed inline so I had to keep the animation terse (and admittedly a bit too fast).

It is indeed using fzf in a specialized way so that it only searches for git worktrees and nothing more. The use case I have is that I have dozens or hundreds of repos in various locations on disk and this tool makes it easy to instantly jump into any of them.

That's why it's called "gcd" -- git + cd.

When I was in university around 2001/2002 my partner's close friend was an intern in 3M's legal department. At the time she noted that she was helping to ensure that 3M was never legally liable for teflon and related products.

https://github.com/davvid/garden

Project Description: Garden is a git multi-repo powertool. Garden lets you define custom workflows over arbitrary collections of git trees.

If you find yourself running bespoke commands across a smattering of git repositories then Garden can be a big improvement over a big pile o' scripts and repos.

What do you want to be tested: Test the documented feature-set and new-user onboarding experience. Give feedback on its usefulness as a development/testing aid.

Contact Info: Open an issue on the project page

Here's a nifty python module for testing against postgres that a friend wrote. It creates a temporary database on the fly for testing and tears it down at the end. You can then populate the database and run all kinds of integration tests against it.

https://github.com/ugtar/pg_temp

If you're into this kinda thing then then you might be interested in my take on improving over a "big pile o scripts" (and repos).

https://github.com/davvid/garden

Garden is a multi-repo powertool for running custom commands and mashing random shell scripts and loosely-coupled repos into a version-controllable config file. If you're weird like me you might like it.

If you remember Impulse Tracker (DOS), schismtracker is a modern day clone:

https://github.com/schismtracker/schismtracker

For maximum enjoyment (and I do mean maximum), please follow this order in reading/listening and do not skip/surf any of them. It all builds.

Please read this academic paper first:

https://arxiv.org/ftp/arxiv/papers/1811/1811.02035.pdf

Then read this (this will remind you what you should be focusing on in the above academic paper):

https://www.bbc.com/future/article/20190919-the-maze-puzzle-...

Then, listen to this:

https://www.wnycstudios.org/podcasts/tnyradiohour/segments/u...

At this point, you have hit the peak ... this last paper is the wrap-up which isn't all that much "fun" but does tie up loose ends:

https://intarch.ac.uk/journal/issue59/3/index.html

Cut and paste

If your terminal supports it (iterm, kitty, later versions of gnome-terminal and others) this osc52 plugin is really sweet. It even works over ssh.

https://github.com/ojroques/vim-oscyank/

The OpenEXR file format, used a lot in graphics applications (compositing, rendering), is a fairly well-known application of half-floats.

There's some notes about the advantages of half-float pixel in the openexr documentation: https://openexr.readthedocs.io/en/latest/TechnicalIntroducti...

I don't think "obvious" was the best adjective, but "small memory/file size footprint" is probably the quality that's easiest to understand.

There is active work related to teaching "git rebase" to natively support stacked branches in the Git core currently being worked on by Derrick Stolee [1].

If you "stack" your changes across multiple inter-dependent branches it looks like "git rebase" is going to learn how to update related branches using a new "update-ref" command (alongside "squash", "fixup", "exec", etc) that gets activated automatically through a "git rebase --update-refs" command-line flag and config option.

(This is from Derrick, not me)

""" This is a feature I've wanted for quite a while. When working on the sparse index topic, I created a long RFC that actually broke into three topics for full review upstream. These topics were sequential, so any feedback on an earlier one required updates to the later ones. I would work on the full feature and use interactive rebase to update the full list of commits. However, I would need to update the branches pointing to those sub-topics.

This series adds a new --update-refs option to 'git rebase' (along with a rebase.updateRefs config option) that adds 'git update-ref' commands into the TODO list. This is powered by the commit decoration machinery.

"""

This is under active development (I don't believe the topic has been merged yet) so it's still open for feedback and refinement on the git development mailing list. Thanks Derrick!

[1] https://public-inbox.org/git/pull.1247.git.1654263472.gitgit...

For context, this is The Amalgamation: https://www.sqlite.org/amalgamation.html