git-from-the-bottom-up VS clojure-style-guide

Very tangential:

Gerrit also stores some of its configs in a git repo. I was setting up a new instance, but couldn't get Admin permissions because the way my auth front-end didn't play well with the docker image's assumptions.

Gerrit already does a lot of its work via non-standard references. For example, you don't push to a branch, `refs/branches/foo`, you push to a separate `refs/for/foo` namespace that creates the review.

Similarly, Group config is stored in the All-Users git repo [1], but in references created after a UUID, in `refs/groups/UU/UUID`.

I ended up having a to exercise the plumbiest of plumbing commands [2] to create a new commit from scratch (from a tree, from the index, from blobs), to update the group ref to add myself to the Administrators group (this, of course, requires a local shell and permissions on the Gerrit host). It was a great way to exercise what I had learned in Git from the Bottom Up [3]

[1] https://gerrit-review.googlesource.com/Documentation/config-...

[2] https://git-scm.com/book/en/v2/Git-Internals-Git-Objects

[3] https://jwiegley.github.io/git-from-the-bottom-up/

You won't have to put your entire life on break in order to understand the fundamentals of git and why it works the way it works. Going through https://jwiegley.github.io/git-from-the-bottom-up/ and really understanding the material will take you a couple of hours at max, but will save you a lot of time in the future.

Wanting to understand things before using them is hardly elitism, not sure why you would think that.

Just like you probably don't want to fix bugs without understand the cause, it's hard to use a tool correctly unless you know how the tool works.

If that's too dense, read https://jwiegley.github.io/git-from-the-bottom-up/, which is basically the same as chapter 10 at a slower pace.

Git From The Bottom Up : https://jwiegley.github.io/git-from-the-bottom-up/

here's one tutorial https://jwiegley.github.io/git-from-the-bottom-up/ from bottom to top, it explains the building blocks then the operations, it might help (again, depending on your brain)

I can recommend https://jwiegley.github.io/git-from-the-bottom-up/ and of course https://git-scm.com/docs/gittutorial (also gittutorial-2).

It's not a single digit minute read, but to me "Git from the Bottom Up" was what really made me understand git a long time ago.

https://jwiegley.github.io/git-from-the-bottom-up/

git's the kind of tool where understanding how your commands operate on the underlying data structures will probably make it a lot easier to use efficiently. (And they're beautifully simple despite how powerful and flexible they are)

As a tool you might be using for hours per week for a few more decades, it's worth the investment going beyond the "in x minutes". I tend to provide both to juniors.

Obligatory: https://xkcd.com/1597/

Fixed link to that style guide entry: https://guide.clojure.style/#opt-commas-in-map-literals

Per that style guide, the above map would be formatted like this (on HN, just indent by two spaces):

  {:a 1

Basically, you learn the expected places to put whitespace, make sure to edit your code accordingly and all of the parens will be automatically closed and adjusted. Using parinfer—which you can also combine with the more traditional paredit—makes writing Clojure code a lot like writing Python.

Also, there are guidelines, the styleguide, clj-kondo, kibit etc. And if you don't review your interns/juniors code to teach them good practices - you're doing it wrong (well, this one is true for any practical PL out there).

Another good resource is https://guide.clojure.style/ -- the (unofficial) community style guide for Clojure.

It's not an answer to your question but i can refer you to https://github.com/bbatsov/clojure-style-guide

Formatting is not that great, see https://github.com/bbatsov/clojure-style-guide btw

The Clojure Style Guide

The Clojure Style Guide - A community coding style guide for the Clojure programming language.