The Wiert Corner – irregular stream of stuff

A few years back [Wayback/Archive] 🔎Julia Evans🔍 (@b0rk) / Twitter asked for tips on learning git which resulted in a wealth of resources.

Related: [Wayback/Archive] xkcd: Git

So the below are for my link archive.

Yes, I have removed most of not all Unicode emojis as they are a pain for visually impaired to listen to from screen readers.

• [Wayback/Archive] Julia Evans on Twitter: “do you have any favourite interactive tools to learn git? (like visualizations / games / playgrounds) I have an idea for a tool I might build and I’m looking for prior art.”
  • [Wayback/Archive] Julia Evans on Twitter: “ohmygit.org by @blinry looks really nice and it’s pretty much exactly what I was thinking about — it lets you explore and it uses a real git repository & command line”
    • [Wayback/Archive] Oh My Git!
    • [Wayback/Archive] Jeremy Sher/‏שאַקיל אָ’ניל on Twitter: “@b0rk @blinry Time machine is my favorite metaphor for teaching git! Especially once you start getting multiple time travelers affecting the same timeline and creating paradoxes/conflicts”
    • [Wayback/Archive] David Alpert (still masking in public) on Twitter: “@b0rk @blinry I’m a huge fan of …”
      • [Wayback/Archive] Learn Git Branching
  • [Wayback/Archive] Sundeep  on Twitter: “@b0rk I haven’t tried it out yet, but I saw git.bradwoods.io on Hacker News some time back.”
    • [Wayback/Archive] Git Time
  • [Wayback/Archive] Nicky on Twitter: “@b0rk Githug was the thing that really helped me: …”
    • [Wayback/Archive] Gazler/githug · GitHub
      

      Githug is designed to give you a practical way of learning git. It has a series of levels, each requiring you to use git commands to arrive at a correct answer.

• [Wayback/Archive] Julia Evans on Twitter: “what’s your favourite resource for learning Git? what explanation made it click for you?”
  • [Wayback/Archive] Alex Chan on Twitter: “@b0rk I wrote a workshop about Git internals a few years ago; I don’t remember what I read beforehand, but writing that really helped me wrap my head round it: …”
    • [Wayback] Git Internals PDF by [Wayback/Archive] Scott Chacon (@chacon) (with source code at [Wayback/Archive] pluralsight/git-internals-pdf: PDF on Git Internals)
    • [Wayback/Archive] A Plumber’s Guide to Git – alexwlchan
      1. [Wayback/Archive] Part 1: The Git object store – alexwlchan
      2. [Wayback/Archive] Part 2: Blobs and trees – alexwlchan
      3. [Wayback/Archive] Part 3: Context from commits – alexwlchan
      4. [Wayback/Archive] Part 4: Refs and branches – alexwlchan
      5. [Wayback/Archive] A Plumber’s Guide to Git: Conclusion – alexwlchan
  • [Wayback/Archive] Jonathan King on Twitter: “@b0rk This lecture from MIT and in particular the focus on the underlying data structure, before introducing git commands. …” and[Wayback/Archive] Jan van den Berg on Twitter: “@b0rk This one …”
    • [Wayback/Archive] Version Control (Git) · the missing semester of your cs education
      • [Wayback/Archive] Lecture 6: Version Control (git) (2020) – YouTube
  • [Wayback/Archive] Erik on Twitter: “@b0rk Personally I found the resources from @gittower helpful. They are written for their GUI (which I recommend) but for the command line as well. …”
    • [Wayback/Archive] Learn Version Control with Git for Free | Learn Version Control with Git
      • [Wayback/Archive] Learn Git with Our Free Online Book | Learn Version Control with Git
        

        Version control is an essential tool if you want to be successful in today’s web & software world. This online book will help you master it with ease.

      • [Wayback/Archive] First Aid Kit for Git | Learn Version Control with Git
        

        Learn how to undo and recover from mistakes in Git. With our super-fast, super-easy videos and a handy cheat sheet.

      • [Wayback/Archive] Live Webinar – 17 Ways to Undo Mistakes with Git | Learn Version Control with Git
        

        In this 1-hour webinar, we show you how Git can save your neck – by helping you roll back, revert, and generally undo almost any mistakes that might happen.

      • [Wayback/Archive] Learn Git with Our Free Video Course | Learn Version Control with Git
        

        Learn version control with Git – with our step-by-step video course. Each lesson covers just a single topic and has an average duration of only 5 minutes.

      Note you have to mandatory sign up for the newsletter in order to get the cheat sheets, first aid kit or other on-line content. I do not think this is GDPR compliant.

  • [Wayback/Archive] convenient exposition owl on Twitter: “@b0rk …”
    • [Wayback/Archive] Git from the inside out
  • [Wayback/Archive] Guillaume Téchené on Twitter: “@b0rk https://learngitbranching.js.org is amazing”
    • [Wayback/Archive] Learn Git Branching
  • [Wayback/Archive] Oscar D Þorson  on Twitter: “@b0rk git-scm.com/book/en/v2“ and[Wayback/Archive] Keith Smith on Twitter: “@b0rk The Pro Git book is an easy read and gives a solid grounding on the fundamentals. git-scm.com/book/en/v2“
    • [Wayback/Archive] Git – Book
  • [Wayback/Archive] phillip kerman on Twitter: “@b0rk atlassian.com/git Just very well written, good figures too.” and[Wayback/Archive] Nathan Moore on Twitter: “@b0rk Weirdly, Bitbucket/Atlassian introduction to git. There aren’t many commands that are regularly required, and the rest are available with git -h. Then, convincing other people to use it as well, moving away from v3-final-print“
    • [Wayback/Archive] Learn Git- Git tutorials, workflows and commands | Atlassian Git Tutorial
  • [Wayback/Archive] Pepijn Vossen on Twitter: “@b0rk This one: …”
    • [Wayback/Archive] Learn Git The Hard Way by Ian Miell [Leanpub PDF/iPad/Kindle]
  • [Wayback/Archive] Karl Puder on Twitter: “@b0rk So far, I use sourcetreeapp.com until I need something that it does not make obvious. Then I read “man git-whatever” pages and experiment on a toy repository until I figure it out. In a hurry, I Google it up and hope to understand what it finds.”
    • [Wayback/Archive] Sourcetree | Free Git GUI for Mac and Windows
    • [Wayback/Archive] Karl Puder on Twitter: “@b0rk My eyes were opened when I read that Linus implemented the features he needed in the order that he needed them, so the command-line interface makes some rare actions easy and some common actions require options. Don’t expect it to make sense, just use the useful idioms.“
  • [Wayback/Archive] Chernetskyi on Twitter: “… “
    • [Wayback/Archive] Commits are snapshots, not diffs | The GitHub Blog
      

      • Boxes are blobs. These represent file contents.
      • Triangles are trees. These represent directories.
      • Circles are commits. These are snapshots in time.

      

      Important to observe here is that contents (blobs) is split from metadata (trees and commits). All three are stored in files; blobs can binary or text, trees and commits are always text. All three have object-ID (OID) hashes which can be referred to by references (tags, branches).

  • [Wayback/Archive] Ben on Twitter: “@b0rk dangitgit.com“
    • [Wayback/Archive] Dangit, git!
      

      So here are some bad situations I’ve gotten myself into, and how I eventually got myself out of them in plain english*.

  • [Wayback/Archive] Will Charczuk on Twitter: “@b0rk stevelosh.com/blog/2013/04/git-koans/…“[Wayback/Archive] Will Charczuk on Twitter: “@b0rk Mostly because it made me realize that I wasn’t alone in feeling that git’s api is confusing.”
    • [Wayback/Archive] Git Koans / Steve Losh (situations where git is confusing or even destructive)
  • [Wayback/Archive] Aaron on Twitter: “@b0rk I got more comfortable with git after reading this paper. It argues that git’s abstractions just aren’t a good mental model for humans. So I stopped trying to understand it and just focused on learning the specific tasks I needed to get good at. spderosso.github.io/oopsla16.pdf“
    • [Wayback/A] spderosso.github.io/oopsla16.pdf
  • [Wayback/Archive] Ian Coldwater  on Twitter: “@b0rk ohshitgit.com is an all-time classic”
    • [Wayback/Archive] Oh Shit, Git!?!
      

      So here are some bad situations I’ve gotten myself into, and how I eventually got myself out of them in plain english.

    • Indeed: both “Dangit, git!” and “Oh Shit, Git!?!” share the same repository at [Wayback/Archive] ksylor/ohshitgit: The official home of Oh Shit, Git!?!
      

      The official home of Oh Shit, Git!?! https://ohshitgit.com/ (and the swear-free version at Dangit, Git!?! https://dangitgit.com/

  • [Wayback/Archive] Jelte Jansen on Twitter: “@b0rk Not sure who said it, but “Git gets easier once you understand branches are homeomorphic endofunctors mapping submanifolds of a Hilbert space.””
    • [Wayback/Archive] Jelte Jansen on Twitter: “@b0rk More seriously, I can’t point to any specific resource, but what made it click for me was the realization that a commit is a changeset, not a pointer to a state of the codebase. A repository is a giant tree of those changesets, and branches are pointers to elements in the tree“
    • [Wayback/Archive] Jelte Jansen on Twitter: “@b0rk This made what things like merge, rebase and fast-forward are much easier to grok for me, as well as knowing when to use which“
  • [Wayback/Archive] Alicja with a J on Twitter: “@b0rk @maryrosecook wrote a blog post and a heavily annotated implementation in JS, both helped me a ton! maryrosecook.com/blog/post/git-from-the-inside-out…“
    • [Wayback/Archive] Git from the inside out
    • by [Wayback/Archive] Mary Rose Cook (@maryrosecook)
  • [Wayback/Archive] rememberthecant on Twitter: “@b0rk (1/4) Ah, I have insight here! I spent A LOT of time struggling to learn Git as a CS grad student. Two very clear lightbulb moments for me:”
    • 1. [Wayback/Archive] rememberthecant on Twitter: “@b0rk (2/4) 1. A commit is a pointer to another* commit, plus deltas*. I spent awhile bogged down learning about commits, merges, and branches, etc.; learning this one simple thing about the underlying structure immediately made everything clear.”
      2. [Wayback/Archive] rememberthecant on Twitter: “@b0rk (3/4) 2. You’ve got to create a local branch to mirror the remote, or everything breaks. This one was awful. I spent so much time struggling with cryptic error message about detached heads and such – this was responsible for like 95% of my Git issues.”
    • [Wayback/Archive] rememberthecant on Twitter: “@b0rk (4/4) (* As you’re probably aware, merges might point to multiple commits, and evidently Git stores file snapshots instead of deltas, but those weren’t important for informing my early understanding.)”
  • [Wayback/Archive] Kevin Bost on Twitter: “@b0rk #gitkraken has a pretty good set of tutorials. Most of the material is just about git in general and not specific to your tool of choice. gitkraken.com/learn/git/tutorials“
    • [Wayback/Archive] Git Tutorials | Learn Git covering many topics (all having a video) on three levels plus some additional resources:
      

      • Beginner Git Tutorials: repository, commit, remote, branch (create/delete/rename), SSH, diff, checkout, pull
      • Intermediate Git Tutorials: merge, shash, hooks, squash, pull request, cherry pick, rebase
      • Advanced Git Tutorials: merge conflict, LFS, submodule
        • How to Resolve a Merge Conflict in GitWhat is a merge conflict? How do you resolve merge conflicts in Git? Learn when a merge conflict in Git will occur and how to resolve them.What is Git LFS?
        • What is Git LFS? How do you install Git LFS? Learn how to use Git LFS to save space in your remote repository when working with binary files in Git.
        • What is a Git Submodule?How do you work with Git submodules? How do you add a Git submodule? Learn how to add a Git submodule and how to pull changes to your main project.
      • Additional Resources: good commit messages, push remote, undo commit, push force, github fork, github delete

  • [Wayback/Archive] Daniil Marchenko on Twitter: “@b0rk For visual learners that need step by step intro: …”
    • [Wayback/Archive] Learn Git Branching
    • [Wayback/Archive] Christinah on Twitter: “@sonofhammer @b0rk Came here to post this ^ Although just running gitk --all & was the most useful thing to get the basic idea of wtf was happening”
  • [Wayback/Archive] Ⓐ Pangolin, the Armored Autist on Twitter: “@b0rk @IanColdwater I don’t have an answer, but if I ever find a good explanation of cherry pick which isn’t wrapped by a GUI and which I can remember for more than five minutes, it’d be great.”
  • [Wayback/Archive] spaceworm on Twitter: “@b0rk Jim Weirich’s Source Control Made Easy video is what made it click for me. Walks through inventing git by progressive enhancement, starting from copy file.1 and rename to file.2″
    • [Wayback/Archive] spaceworm on Twitter: “@b0rk For a while @pragprog was still selling it to benefit Jim’s family, but it doesn’t seem to be available anymore. I wish they would release it again, it’s great.”
    • [Wayback/Archive] spaceworm on Twitter: “@b0rk @pragprog RIP, Jim. We miss you.”
    • [Wayback/Archive] spaceworm on Twitter: “@pragprog @b0rk Any chance you could publish that talk on YouTube or something? It’s a classic, the best explanation I have encountered of how git works.”
  • [Wayback/Archive] Alisdair Meredith on Twitter: “@b0rk When my employer moved to git, they gave us training based upon jwiegley.github.io/git-from-the-bottom-up…, and everything just clicked. As a software developer, this presents the ideas behind git in ways that are intuitive to us, before detailing commands and workflow.”
    • [Wayback/Archive] Git from the Bottom Up which starts with a great list of terms; after reading this page, you should be able to explain all of them (repository, index, working tree, commit, branch, tag, main (previously master), HEAD)
  • [Wayback/Archive] Valentin Baca on Twitter: “@b0rk Git Pocket Guide. It’s tiny and short. Can read it on your commute or between builds. It’s great. It’s cheap…it’s also a bit outdated, so it won’t have more recent “git switch” and “git restore” but in terms of understanding the fundamentals, it’s still solid IMO. “
    

    

  • [Wayback/Archive] Will Charczuk on Twitter: “@b0rk stevelosh.com/blog/2013/04/git-koans/…”
    • [Wayback/Archive] Will Charczuk on Twitter: “@b0rk Mostly because it made me realize that I wasn’t alone in feeling that git’s api is confusing.”
    • [Wayback/Archive] Git Koans / Steve Losh
  • [Wayback/Archive] Sam Livingston-Gray on Twitter: “@notragegod @b0rk I think of rebase as a fancy way to batch cherry-pick operations. (Because, under the hood, they’re the same thing!)“
  • [Wayback/Archive] James Healy on Twitter: “@b0rk @chacon’s railsconf 2008 talk made it click for me, by working up from the data structures. schacon.github.io/2008/06/02/railsconf-git-talk.html… Seems like it’s fallen off the internet, but similar to youtube.com/watch?v=xbLVvrb2-fY… I think”
    • [Wayback/Archive] Scott Chacon – RailsConf Git Talk by [Wayback/Archive] Scott Chacon (@chacon)
    • [Wayback/Archive] RailsConf 2008 Git Talk by Scot Chacon Video on Vimeo
    • [Wayback/Archive] Introduction to Git – talk by Scott Chacon – YouTube
  • [Wayback/Archive] ${jndi:ldap://ldap.mallya.dev} on Twitter: “@b0rk …”
    • [Wayback/Archive] Introduction to Git — talk by Scott Chacon – YouTube
  • [Wayback/Archive] Holly Becker on Twitter: “@b0rk think-like-a-git.net is my favorite “I know that commands but not what they’re doing” resource. Good explanation of rebase, branches, and how to make a backup/checkpoint so you can experiment more safely” and[Wayback/Archive] Gabriel Pettier  on Twitter: “@b0rk It’s been some time, but think-like-a-git was a very useful, and not too long read to me think-like-a-git.net really gave me a solid enough fondation.”
    • [Wayback/Archive] Cascadia 2011 – Think like a Git by Sam Livingston-Gray – YouTube
    • [Wayback/Archive] Home // Think Like (a) Git
      • with source at [Wayback/Archive] geeksam/think-like-a-git-dot-net: Source for http://think-like-a-git.net/
      • ad a summary at [Wayback/Archive] TL;DR // Think Like (a) Git:
        

        • Git is an incredibly powerful tool, but it can be hard to learn.
        • It helps to know something about [Wayback/Archive] graph theory, especially with regard to [Wayback/Archive] reachability.
        • And to know what Git’s [Wayback/Archive] references are.
        • Because [Wayback/Archive] references make commits reachable.
          (Only got time to read one page? Make it that one.)
        • Once you understand that, you won’t waste so much time backing up your entire repository, [Wayback/Archive] like I did.
        • [Wayback/Archive] I like GitX, and you can use it (or another visualizer) to bootstrap your knowledge of Git.
        • I’ve got a few recipes for [Wayback/Archive] testing out merges that give you an “undo” option.
        • And I’ve attempted to explain [ Wayback/Archive] rebase as simply as I can.

      • [Wayback/Archive] Resources // Think Like (a) Git pointing to a lot of information and to useful tools like:
        • [Wayback/Archive] jonas/tig: Text-mode interface for git with documentation at [Wayback/Archive] Introduction · Tig – Text-mode interface for Git (which used to be at [Wayback/Archive] Index of /tig)
        • [Wayback/Archive] The Thing About Git
          

          The Index is also sometimes referred to as The Staging Area, which makes for a much better conceptual label in this case. I tend to think of it as the next patch: you build it up interactively with changes from your working copy and can later review and revise it. When you’re happy with what you have lined up in the staging area, which basically amounts to a diff, you commit it. And because your commits are no longer bound directly to what’s in your working copy, you’re free to stage individual pieces on a file-by-file, hunk-by-hunk basis.

          …

          • git add --patch is actually a shortcut to features in git add --interactive, a powerful front-end for managing all aspects of the staging area.
          • git commit --amend takes the changes staged in the index and squashes them into the previous commit.
          • And then there’s git rebase --interactive, which is a bit like git commit --amend hopped up on acid and holding a chainsaw…
          • People seem to get a lot of utility out of git-stash(1), which lets you move changes from your working copy into a lightweight holding area to be reintroduced some time later.

        • [Wayback/Archive] git awsome-ness [git rebase --interactive] – MadBlog (which is from a blog that is by now unavailable due to link rot)
          

          What the small help doesn’t say is that you can actually reorder your commits, and it will do what you expect it to do.

        • [Wayback/Archive] Git and GitHub Basics | Salesforce Trailhead (though GitHub and handling of its features like issues and pull-requests would warrant a new Twitter thread and blog post)
        • [Wayback/Archive] The illustrated guide to recovering lost commits with Git – Programblings showing how to recover from various scenarios using a wealth of git commands rebase, branch, status, diff, stash, fsck, stash, rebase, reset, merge, cherry-pick, checkout, apply, commit, gc, prune.
        • [Wayback/Archive] Production Release Workflow with Git showing that you do not need many branches or a complex branching strategy as long as you actively keep an eye on what is going on inside your teams.
        • [Wayback/Archive] “Algorithm” is Not a Four-Letter Word
      • [Wayback/Archive] HALP! // Think Like (a) Git
        

        If you’ve just lost some work in Git, and you’re trying to recover your lost commits, this page is for you.

  • [Wayback/Archive] Henrik Warne on Twitter: “@b0rk I read a lot of different guides and explanations. It still took me quite a while to really understand it. Using git a lot is key though. A few years ago I wrote down several “aha-moments” I had after using git for quite a while: …”
    • [Wayback/Archive] 6 Git Aha Moments | Henrik Warne’s blog
  • [Wayback/Archive] David Turner on Twitter: “@b0rk The Internals section of Pro Git. I recognize that it is a terrible user experience to have to understand the internals of a tool in order to use it, but nonetheless, that’s what I recommend to people.”
  • [Wayback/Archive] Zac Delventhal  on Twitter: “@b0rk @IanColdwater For me all that really helped was just using git. In particular, incorporating these two commands into my regular workflow: git add --patch  git rebase --interactive These allowed me to work more freely with git, and really start thinking of my code as a series of diffs.“
  • [Wayback/Archive] Dave Hirschfeld on Twitter: “@b0rk I think Alice Bartlett’s Git for Humans presentation is an *excellent* resource for non-developers. …”
    • [Wayback/Archive] Git for Humans – Speaker Deck by [Wayback/Archive] Alice Bartlett (@alicebartlett)
    • [Wayback/Archive] Git for Humans – Alice Bartlett at UX Brighton 2016 – YouTube
  • [Wayback/Archive] James Fuller on Twitter: “@b0rk Eric Sink’s Version Control By Example, I picked up for Mercurial a decade ago, but always used it as a reference for newer teammates. It quickly walks the individual through most common aspects in a few dozen pages. ericsink.com/vcbe/index.html“
    • [Wayback/Archive] Version Control by Example book
      • • [Wayback/Archive] Version Control by Example on-line version (there are also PDFs and print versions)
  • [Wayback/Archive] Claire Curry on Twitter: “@b0rk Teaching/helping with the Software Carpentry git lesson: swcarpentry.github.io/git-novice“
    • [Wayback/Archive] Version Control with Git (~3 hour course)
  • [Wayback/Archive] Wes Lord on Twitter: “@b0rk I went from being a Git user to being a Git understander when I found @tlberglund’s “Git from the Bits Up”. Uses an excellent trick to visualize what’s actually happening at every step. “
    • [Wayback/Archive] Git From the Bits Up – YouTube by [Wayback/Archive] Tim Berglund (@tlberglund)
      

      Join GitHub trainer and evangelist Tim Berglund for a look at Git, from the bits up. This talk is not for the Git beginner, but a more advanced look at “weird internals stuff” and obscure commands that will reveal a sort of internal API that is there for you to use and help expose you to certain intrinsic software design insights that can be had from looking at Git at this level.

    • [Wayback/Archive] Wes Lord on Twitter: “@b0rk @tlberglund The most important change: I stopped trying to imagine branches as being the “entire branch” and realized a branch in Git is just a label pointing at one commit.“
    • [Wayback/Archive] Tim Berglund on Twitter: “@weslord @b0rk Yes! This is key. A branch is just a label for a commit, plus a bit of automation that moves the label forward to the new commit when you’re “on” that branch. It’s really simple, but it’s also very difficult to see that simplicity through all the details.“
    • [Wayback/Archive] Wes Lord on Twitter: “@tlberglund @b0rk I think my misunderstanding was driven by the naming convention, plus the way the graph typically gets color-coded (or worse, drawn on rails!) in visualizations. …”
  • [Wayback/Archive] Carina C. Zona on Twitter: “@b0rk I had been using and teaching git for years when @geeksam’s think-like-a-git.net entered my life. It not only made git’s “quirkiness” make sense, but also was a nice introduction to graph theory overall. Plus it led to a friendship with Sam, who is the coolest cat around.”
    • [Wayback/Archive] Home // Think Like (a) Git by [Wayback/Archive] Sam Livingston-Gray (@geeksam)
  • The movie analogy is nice:
    • [Wayback/Archive] K. Ryabitsev on Twitter: “@b0rk In terms of repository structure, I like to compare git to a movie. Every commit creates a still frame of your entire tree. Even if you change one byte in a file and commit it, git will still make a whole new still frame of your entire tree.“
    • [Wayback/Archive] K. Ryabitsev on Twitter: “@b0rk Branches are alternative diverging timelines that must be somehow reconciled with the main timeline to be merged back, or be abandoned.“
  • [Wayback/Archive] James Lamb on Twitter: “@b0rk I learned from gitimmersion.com and found it really helpful that it was so intentional about the order things were introduced.” and[Wayback/Archive] Matthew D. Groves on Twitter: “@b0rk Got to be gitimmersion.com“
    • [Wayback/Archive] Git Immersion
      

      A guided tour that walks through the fundamentals of Git, inspired by the premise that to know a thing is to do it.

  • The concept of references is tricky: which kind of reference has which lifetime?
    • [Wayback/Archive] Larry Reid (he/him) on Twitter: “@b0rk I forget where I saw it, but the statement: “A branch is just a yellow sticky note on all the commits,” made a lot fall into place for me.”
      • [Wayback/Archive] Sidharth Masaldaan on Twitter: “@lenchoreyes @b0rk Is it from Git for Ages 4 & up? That’s what really made it click for me”
    • [Wayback/Archive] Corneil du Plessis. on Twitter: “@lenchoreyes @adymitruk @b0rk That’s a tag.”
    • [Wayback/Archive] Adam Dymitruk on Twitter: “@corneil @lenchoreyes @b0rk A sticky note you can move easily. A tag is more like a pin.“
  • [Wayback/Archive] James Ashmore on Twitter: “@b0rk …”
    • [Wayback/Archive] Version Control with Git | Udacity Free Courses (which takes about 4 weeks)
  • [Wayback/Archive] Marc Mercer on Twitter: “@b0rk Trial by fire, AND tools like gitkraken, gitblade, etc.. Sometimes, having a tool to visualize things (like the reflog, rebases, etc) helps us remember how things work. That and having to navigate pretty deeply through the reflog for detached branches/commits/etc and rebuild..”
  • [Wayback/Archive] Justin McGuire on Twitter: “@b0rk Coming from an SVN background, the thing that hit home for me was the old “HG Init” site by @spolsky . It was written for Mercurial, but the overarching reason of “why would you want this weird, new thing” really hit home. hginit.github.io/00.html“
    • [Wayback/Archive] HgInit: Subversion Re-education (beginner, but very insightful)
  • [Wayback/Archive] Raja Ravi Varma on Twitter: “@b0rk I go back to this tutorial all the time. This is by the Gitolite author gitolite.com/gcs.html#(1)”
    • [Wayback/Archive] git concepts simplified (1) (note both archivals are empty)
  • [Wayback/Archive] Jefe de Queso on Twitter: “@b0rk After I had the fundamentals down, experimenting with this helped to clarify how some of the commands work git-school.github.io/visualizing-git/…“
    • [Wayback/Archive] Visualizing Git (looks a lot like Explaining Git with D3″, and indeed: it is when you look at the source below)
      • [Wayback/Archive] git-school/visualizing-git: Visualize how common Git operations affect the commit graph
        

        Git is an amazingly powerful tool — and it can be amazingly confusing. Demystify Git commands with visualizations powered by D3.

  • [Wayback/Archive] Ando G on Twitter: “@b0rk After having worked initially exclusively more than 5 years with mercurial my clicking moment was seeing an old documentation of cvs and understanding its commands. Suddenly git’s command structure made sense.“
  • [Wayback/Archive] Josh Dick on Twitter: “@b0rk This excellent article from @nfarina is now over 10 years old but is still extremely relevant, and was my “aha” resource for understanding Git: nfarina.com/post/9868516270/git-is-simpler… It provides a fantastic foundation to understand the much greater detail in “Pro Git”.”
    • [Wayback/Archive] Nick Farina – Git Is Simpler Than You Think by [Wayback/Archive] Nick Farina (@nfarina) | Twitter
  • [Wayback/Archive] Chris Selzo on Twitter: “@b0rk youtu.be/1ffBJ4sVUb4. The tinker toys really clicked for me”
    • [Wayback/Archive] [Linux.conf.au 2013] – Git For Ages 4 And Up – YouTube
  • [Wayback/Archive] David Blanchet on Twitter: “@b0rk Implementing my own version after having read gitlet.maryrosecook.com/docs/gitlet.html…, but in another language (Python for that matter).”
    • [Wayback/Archive] gitlet.js
      

      This code is intended to show how Git works under the covers. It is written to be readable. It is heavily commented.

      with source at [Wayback/Archive] maryrosecook/gitlet: Git implemented in JavaScript.

  • [Wayback/Archive] Michael Hunger  on Twitter: “@b0rk The git parable back then by @mojombo tom.preston-werner.com/2009/05/19/the-git-parable.html…“ and[Wayback/Archive] halcanary on Twitter: “@b0rk THIS: tom.preston-werner.com/2009/05/19/the-git-parable.html…“
    • [Wayback/Archive] The Git Parable by [Wayback/Archive] Tom Preston-Werner (@mojombo):
      

      The following parable will take you on a journey through the creation of a Git-like system from the ground up. Understanding the concepts presented here will be the most valuable thing you can do to prepare yourself to harness the full power of Git.

    [Wayback/Archive] Johan Herland on Twitter: “@b0rk I read tom.preston-werner.com/2009/05/19/the-git-parable.html… back in 2009. Found it so good that I reformatted it into a talk (youtu.be/jm7QsI-nNjk) and have used it to teach Git to old and new colleagues for the last 12 years.” / Twitter

    • [Wayback/Archive] The Git Parable – a different approach to understanding Git (90 min) – Johan Herland – YouTube
  • [Wayback/Archive] Julien Jerphanion on Twitter: “@b0rk GitHub’s ressources for daily things or to start learning. Then the manual (git-scm.com/docs) to build a deeper understanding of concepts and commands.”
    • [Wayback/Archive] Git – Reference
  • [Wayback/Archive] Derek Scherger on Twitter: “@b0rk onlywei.github.io/explain-git-with-d3/… is quite good” (looks a lot like “Visualizing Git”)
    • [Wayback/Archive] Explain Git with D3 (source at [Wayback/Archive] onlywei/explain-git-with-d3: Use D3 to visualize simple git branching operations.)
  • [Wayback/Archive] herestomwiththeweather on Twitter: “@b0rk I remember “Understanding Git Conceptually” being very helpful sbf5.com/~cduan/technical/git/…“
    • [Wayback/Archive] Understanding Git Conceptually
  • [Wayback/Archive] Jeremy Provance on Twitter: “@b0rk Resource by @JennyBryan is the best. …”
    • [Wayback/Archive] Let’s Git started | Happy Git and GitHub for the useR
  • [Wayback/Archive] Olivier Rossel on Twitter: “@b0rk What the commit[‘s SHA1] captures. gist.github.com/masak/2415865“
    • [Wayback/Archive] How is git commit sha1 formed
  • [Wayback/Archive] DFIR Notes on Twitter: “@abdoss00 @b0rk I have said: “git is a brilliant data structure in need of an app” along with uncomplimentary (true) things about git(1). GitHub/GitLab and IDEs are the applications needed to use git’s network and disk data structures to work with code. I still like Fossil SCM and svn better.” / Twitter
  • [Wayback/Archive] Aaron on Twitter: “@b0rk I got more comfortable with git after reading this paper. It argues that git’s abstractions just aren’t a good mental model for humans. So I stopped trying to understand it and just focused on learning the specific tasks I needed to get good at. spderosso.github.io/oopsla16.pdf“
    • [Wayback] spderosso.github.io/oopsla16.pdf (Purposes, Concepts, Misfits, and a Redesign of Git, OOPSLA’16, November 2–4, 2016, Amsterdam, Netherlands)
  • [Wayback/Archive] Florent Biville on Twitter: “amazon.com/Version-Control-Git-collaborative-development/dp/1449316387 It went into a lot of details that I forgot since but allowed me to gain confidence using git ever since… “
    • [Wayback/Archive] Version Control with Git: Powerful tools and techniques for collaborative software development: Loeliger, Jon, McCullough, Matthew: 9781449316389: Amazon.com: Books
      

      

  • [Wayback/Archive] Dave Neary on Twitter: “@b0rk It is totally egocentric, but I did a lab on Git once, and I really enjoyed preparing it (and learned a ton in the process!). It’s in French, though: …”
    • [Wayback/Archive] Jeudis du libre_git
  • [Wayback/Archive] Olivier Bonaventure on Twitter: “@b0rk A step-by by guide initially written by a student and later enhanced with interactive exercises (in French), see Introduction to Git on inginious.org/courselist“
    • [Wayback/Archive] Course list | INGInious
    • Actual course: [Wayback/Archive] Tutoriel Git — Tutoriel Git based on the orginal at (but now vanished from): [Wayback/Archive] Git — Systèmes informatiques

Future

Later I want to categorise all these, maybe using categories like these:

• Videos
• Stories/narrations
• Levels (beginner/intermediate/advance)
• Direction (inside-out vs outside-in)
• (Rough) reimplementations
• Perspectives from different version control systems
• Failures: learning from or preventing them

I need to contemplate about that for a while.

--jeroen

Read the rest of this entry »