302 Matching Annotations
  1. May 2022
    1. You could also start a new email with the contents of this file, by making x-success use the mailto: scheme with something like working-copy://x-callback-url/read/?repo=my%20repo&path=README.md&x-success=mailto%3A%3Fbody%3D If you need to debug your callbacks, setting x-success=mailto%3A%3Fbody%3D

      Holy god in fuck...

    1. A properly formed Git commit subject line should always be able to complete the following sentence:If applied, this commit will your subject line hereFor example:If applied, this commit will refactor subsystem X for readability

      An example how to always aim for imperative commits

    2. Git itself uses the imperative whenever it creates a commit on your behalf.For example, the default message created when using git merge reads:Merge branch 'myfeature'

      Using imperative mood in subject line of git commits

    3. Commit messages with bodies are not so easy to write with the -m option. You’re better off writing the message in a proper text editor.

      I've tested it on Windows, and in PowerShell or Git Bash it is as simple as:

      ```console git commit -m "Subject line<ENTER>

      body line 1 body line 2"<ENTER> ```

      However, it does not work in CMD.exe (pressing [ENTER] will not move to the next line)

    4. Firstly, not every commit requires both a subject and a body. Sometimes a single line is fine, especially when the change is so simple that no further context is necessary.

      Not every commit requires a body part

    5. Summarize changes in around 50 characters or less More detailed explanatory text, if necessary. Wrap it to about 72 characters or so. In some contexts, the first line is treated as the subject of the commit and the rest of the text as the body. The blank line separating the summary from the body is critical (unless you omit the body entirely); various tools like `log`, `shortlog` and `rebase` can get confused if you run the two together. Explain the problem that this commit is solving. Focus on why you are making this change as opposed to how (the code explains that). Are there side effects or other unintuitive consequences of this change? Here's the place to explain them. Further paragraphs come after blank lines. - Bullet points are okay, too - Typically a hyphen or asterisk is used for the bullet, preceded by a single space, with blank lines in between, but conventions vary here If you use an issue tracker, put references to them at the bottom, like this: Resolves: #123 See also: #456, #789

      Example of a great commit message

    6. Separate subject from body with a blank lineLimit the subject line to 50 charactersCapitalize the subject lineDo not end the subject line with a periodUse the imperative mood in the subject lineWrap the body at 72 charactersUse the body to explain what and why vs. how

      7 rules of great commit messages

    7. What may be a hassle at first soon becomes habit, and eventually a source of pride and productivity for all involved.
    8. Commit messages can do exactly that and as a result, a commit message shows whether a developer is a good collaborator.
    9. A diff will tell you what changed, but only the commit message can properly tell you why.

      Commit messages are important

    10. Look at Spring Boot, or any repository managed by Tim Pope.
  2. Apr 2022
    1. The eagle-eyed among you may notice that there isn't a .git directory in the app-example-2 working tree. Instead, there's a .git file. This file points to the git directory in the original clone, and it means that all your usual git commands work inside the app-example-2 directory, as well as in the original app-example directory.

      The working of git worktree

    2. Anecdotally, I've found IDEs get much less "confused" if you use their built-in support for switching git branches, instead of changing them from the command line and waiting for the IDE to "notice" the changes.
    1. GIT_INDEX_FILE is the path to the index file (non-bare repositories only).

      export GIT_INDEX_FILE=".git/index.linux" if you are working on Linux

      export GIT_INDEX_FILE=".git/index.windows" if you are working on Linux

  3. Mar 2022
    1. Flatpak is built on top of a technology called OSTree, which is influenced by and very similar to the Git version control system. Like Git, OSTree allows versioned data to be tracked and to be distributed between different repositories. However, where Git is designed to track source files, OSTree is designed to track binary files and other large data.
    2. Internally, Flatpak therefore works in a similar way to Git, and many Flatpak concepts are analogous to Git concepts. Like Git, Flatpak uses repositories to store data, and it tracks the differences between versions.
    1. The underlying architecture might be summarized as “git for operating system binaries”.
    1. $ git config --list http.sslcainfo=C:/Program Files/Git/mingw64/ssl/certs/ca-bundle.crt http.sslbackend=openssl diff.astextplain.textconv=astextplain core.autocrlf=true core.fscache=true core.symlinks=false credential.helper=manager user.name=xxj user.email=hea@exa.com credential.helper=store credential.username=xxxj core.repositoryformatversion=0 core.filemode=false core.bare=false core.logallrefupdates=true core.symlinks=false core.ignorecase=true remote.origin.url=ssh://@ remote.origin.fetch=+refs/heads/:refs/remotes/origin/ branch.master.remote=origin branch.master.merge=refs/heads/master

      此种配置下, git push 出现如下提示:

      fatal: Could not read from remote repository.

      Please make sure you have the correct access rights and the repository exists.



      remote.origin.url=ssh://@ 缺少了 username

  4. Feb 2022
    1. Can't annotate the comments for some reason, so I am copying the below:

      The Jerk talked about getting hit by a bus, etc. I said who cares about code if a guy’s in hospital or there’s a war, we’ve got better things to worry about than a few days of lost code.

      I feel the pain. I do. I understand. I get scared. I want to check in early and often, but source control isn’t your personal unlimited undo. When I look at history I don’t want to see rubbish. I want to see snapshots of working code.

      Don’t hold back, and don’t go dark, but use your f’ing head. It’s far better to locally integrate multiple times per day and merge back after a few days because guess what, no surprises.

    1. You have just told Git to combine all seven commits into the first commit in the list. It's now time to give it a name: your editor pops up again with a default message, made of the names of all the commits you have squashed

      Put the message you like.

    2. mark all the commits as squashable, except the first/older one: it will be used as a starting point

      After git rebase -i HEAD~N or

      git rebase -i [commit-hash] your editor of choice will pop up, showing the list of commits you want to merge and you'll mark a commit as squashable by changing the word pick into squash next to it (or s for brevity, as stated in the comments).

    3. git rebase --interactive [commit-hash]

      Another way, where [commit-hash] is the hash of the commit just before the first one you want to rewrite from. So in my example the command would be.

    4. The first thing to do is to invoke git to start an interactive rebase session

      git rebase --interactive HEAD~N # or -i where N is the number of commits you want to join, starting from the most recent one.

    5. In Git you can merge several commits into one with the powerful interactive rebase

      "glueing" commits with rebase.

    6. It's a handy tool I use quite often; I usually tidy up my working space by grouping together several small intermediate commits into a single lump to push upstream.

      Could be a good practice. During work, I'll commit small chunks of work but when the feature is done they are put together to facilitate code review.

    1. Changing an Older or Multiple Commits

      git rebase -i HEAD~N # N is the number of commits * The command will display the latest X commits in your default text editor; * Move to the lines of the commit message you want to change and replace pick with reword; Save the changes and close the editor; * For each chosen commit, a new text editor window will open; * Change the commit message, save the file, and close the editor; * Use --force in case of pushed commits.

    2. Force push to update the history of the remote repository

      Use --force after ammend a pushed commit.

    3. Generally, you should avoid amending a commit that is already pushed as it may cause issues to people who based their work on this commit. It is a good idea to consult your fellow developers before changing a pushed commit.

      Take care ammending pushed commits

    4. Changing the Most Recent Commit

      git commit --amend

  5. Jan 2022
  6. Dec 2021
    1. At last a git workflow site that makes sense for the 21st century!

    1. it is best to limit the number and scope of branches in your repository. Most implementations suggest that developers commit directly to the main branch or merge changes from their local branches in at least once a day.

      Actually this is the "agile" motto - release early, so no long feature-branches.

  7. Nov 2021
    1. Here are the impressive detailed statistics from their repository as of 2015, for which more recent data is challenging to obtain.

      Interesting statistics (mostly inside diagrams) from 2015 on Google's big [[monorepo]] (which is NOT git).

    1. git ls-files is more than 5 times faster than both fd --no-ignore and find

      git ls-files is the fastest command to find entries in filesystem

    1. The overall flow of Gitflow is: A develop branch is created from main A release branch is created from develop Feature branches are created from develop When a feature is complete it is merged into the develop branch When the release branch is done it is merged into develop and main If an issue in main is detected a hotfix branch is created from main Once the hotfix is complete it is merged to both develop and main

      The overall flow of Gitflow

  8. Oct 2021
    1. Hotfix branches are a lot like release branches and feature branches except they're based on main instead of develop. This is the only branch that should fork directly off of main. As soon as the fix is complete, it should be merged into both main and develop (or the current release branch), and main should be tagged with an updated version number.

      Hotfix branches

    2. Once develop has acquired enough features for a release (or a predetermined release date is approaching), you fork a release branch off of develop. Creating this branch starts the next release cycle, so no new features can be added after this point—only bug fixes, documentation generation, and other release-oriented tasks should go in this branch. Once it's ready to ship, the release branch gets merged into main and tagged with a version number. In addition, it should be merged back into develop, which may have progressed since the release was initiated.

      Release branch

    3. feature branches use develop as their parent branch. When a feature is complete, it gets merged back into develop. Features should never interact directly with main.

      Feature branches should only interact with a develop branch

    4. When using the git-flow extension library, executing git flow init on an existing repo will create the develop branch

      git flow init will create:

      • feature branch
      • release branch
      • hotfix branch
      • support branch
    1. The main condition that needs to be satisfied in order to use OneFlow is that every new production release is based on the previous release. The most difference between One Flow and Git Flow that it not has develop branch.

      Main difference between OneFlow and Git Flow

    2. The most difference between GitLab Flow and GitHub Flow are the environment branches having in GitLab Flow (e.g. staging and production) because there will be a project that isn’t able to deploy to production every time you merge a feature branch

      Main difference between GitLab Flow and GitHub Flow

    3. 4 branching workflows for Git
      1. Git Flow
      2. GitHub Flow
      3. GitLab Flow
      4. One Flow
    4. release-* — release branches support preparation of a new production release. They allow many minor bug to be fixed and preparation of meta-data for a release. May branch off from develop and must merge into master anddevelop.

      release branches

    5. hotfix-* — hotfix branches are necessary to act immediately upon an undesired status of master. May branch off from master and must merge into master anddevelop.

      hotfix branches

    6. feature-* — feature branches are used to develop new features for the upcoming releases. May branch off from develop and must merge into develop.

      feature branches

  9. Sep 2021
  10. Aug 2021
    1. This one implements the behavior of git checkout when running it only against a branch name. So you can use it to switch between branches or commits.

      git switch <branch_name>

    2. When you provide just a branch or commit as an argument for git checkout, then it will change all your files to their state in the corresponding revision, but if you also specify a filename, it will only change the state of that file to match the specified revision.

      git checkout has a 2nd option that most of us skipped

    3. if you are in the develop branch and want to change the test.txt file to be the version from the main branch, you can do it like this

      git chekout main -- test.txt

  11. Jul 2021
    1. rebase is really nothing more than a merge (or a series of merges) that deliberately forgets one of the parents of each merge step.

      What rebase really is

  12. Jun 2021
    1. To try and make things a little bit more secure, Githooks checks if any new hooks were added we haven't run before, or if any of the existing ones have changed
    2. git diff --cached --diff-filter=ACMR --name-only
    1. To address this problem, I offer git undo, part of the git-branchless suite of tools. To my knowledge, this is the most capable undo tool currently available for Git. For example, it can undo bad merges and rebases with ease, and there are even some rare operations that git undo can undo which can’t be undone with git reflog.

      You can use git undo through git-brancheless. There's also GitUp, but only for macOS

    1. From pretty format documentation: '%w([<w>[,<i1>[,<i2>]]])': switch line wrapping, like the -w option of git-shortlog[1]. And from shortlog: -w[<width>[,<indent1>[,<indent2>]]] Linewrap the output by wrapping each line at width. The first line of each entry is indented by indent1 spaces, and the second and subsequent lines are indented by indent2 spaces. width, indent1, and indent2 default to 76, 6 and 9 respectively. If width is 0 (zero) then indent the lines of the output without wrapping them.
    1. There are many projects that does not use the master branch as default. For example, Next.js uses the canary branch, the npm CLI and many more other projects uses stuff like prod, production, dev, develop, release, beta, head.
    2. I'm not sure if there's any cost in terms of contributing either, especially when by design git can have any branch as default, and will not hinder your experience when you use something other than master.

      git is neutral/unbiased/agnostic about default branch name by design

      And that is a good thing

    3. The primary branch in git can have any name by design.
    4. In the context of git, the word "master" is not used in the same way as "master/slave". I've never known about branches referred to as "slaves" or anything similar.
  13. May 2021
    1. Normally, git diff looks for non-printable characters in the files and if it looks like the file is likely to be a binary file, it refuses to show the difference. The rationale for that is binary file diffs are not likely to be human readable and will probably mess up your terminal if displayed. However, you can instruct git diff to always treat files as text using the --text option. You can specify this for one diff command: git diff --text HEAD HEAD^ file.txt You can make Git always use this option by setting up a .gitattributes file that contains: file.txt diff
    1. If you insist on using Git and insist on tracking many large files in version control, you should definitely consider LFS. (Although, if you are a heavy user of large files in version control, I would consider Plastic SCM instead, as they seem to have the most mature solution for large files handling.)

      When the usage of Git LFS makes sense

    2. In Mercurial, use of LFS is a dynamic feature that server/repo operators can choose to enable or disable whenever they want. When the Mercurial server sends file content to a client, presence of external/LFS storage is a flag set on that file revision. Essentially, the flag says the data you are receiving is an LFS record, not the file content itself and the client knows how to resolve that record into content.

      Generally, Merculiar handles LFS slightly better than Git

    3. If you adopt LFS today, you are committing to a) running an LFS server forever b) incurring a history rewrite in the future in order to remove LFS from your repo, or c) ceasing to provide an LFS server and locking out people from using older Git commits.

      Disadvantages of using Git LFS

    1. :/<text>, e.g. :/fix nasty bug A colon, followed by a slash, followed by a text, names a commit whose commit message matches the specified regular expression.

      :/<text> - searching git commits using their text instead of hash, e.g. :/fix nasty bug

    1. git worktree add <path> automatically creates a new branch whose name is the final component of <path>, which is convenient if you plan to work on a new topic. For instance, git worktree add ../hotfix creates new branch hotfix and checks it out at path ../hotfix.

      The simple idea of git-worktree to manage multiple working trees without stashing

    1. Preserving history; we often find ourselves using the git blame tool to discover why a certain change was made.
    2. Preserving commit hashes; we use commit hashes in binary names and our issue tracker; ideally, these references remain intact.
    1. New changes to the old repositories can be imported into the monorepo and merged in. For example, in the above example, say repository one had a branch my_branch which continued to be developed after the migration. To pull those changes in:
    1. [Old commit references] Provide a way for users to use old commit IDs with the new repository (in particular via mapping from old to new hashes with refs/replace/ references).
    2. Let's say that we want to extract a piece of a repository, with the intent on merging just that piece into some other bigger repo.
    1. If you want the project's history to look as though all files have always been in the directory foo/bar, then you need to do a little surgery. Use git filter-branch with the "tree filter" to rewrite the commits so that anywhere foo/bar doesn't exist, it is created and all files are moved to it:
  14. Apr 2021
    1. 🐛 (home, components): Resolve issue with modal collapses 🚚 (home): Move icons folder ✨ (newsletter): Add Newsletter component

      With gitmojis, we can replace the <type> part of a git commit

    2. feat(home, components): Add login modal fix(home, components): Resolve issue with modal collapses chore(home): Move icons folder

      Examples of readable commits in the format:

      <type> [scope]: "Message"

  15. Mar 2021
  16. Feb 2021
    1. The transclusion doesn't automatically change along with it. If transclusions were direct embeds of the original content, we'd end up with link rot on a whole new scale. Every document would be a sad compilation of 404's.

      Thinking about Git repositories, this is how submodules work. you 'freeze' the 'transclusion' to one exact commit and can update if and when needed. Moreover, the contents are stored within the local repository, so they are future-proof.

  17. Jan 2021
    1. master

      Tive problemas ao executar o deploy porque este repo por ser novo já usa o padrao de "main" para o nome da branch principal.

      $ git push heroku main

  18. Dec 2020
    1. Less developer maintenance burden: The existing (Kuma) platform is complex and hard to maintain. Adding new features is very difficult. The update will vastly simplify the platform code — we estimate that we can remove a significant chunk of the existing codebase, meaning easier maintenance and contributions.
    1. Does anyone know how to make npm use a specific fork containing a bug fix while waiting for maintainer to merge a pull request? I was just going to point my package.json to this fork, like this: "svelte-material-ui": "https://github.com/vtpatrickeddy/svelte-material-ui.git#patch-1", but that doesn't work because the repo is a monorepo. And there doesn't appear to be a way to specify a subdirectory inside it, like: "@smui/textfield": "https://github.com/vtpatrickeddy/svelte-material-ui.git/packages/textarea#patch-1",
    1. $ git log --grep "commit message search"

      git blame: searching commit messages themselves with grep

    2. $ git log -S "deleted code" -p

      git blame: way to find deleted piece of code

    3. $ git log -S "some code" -p app/models/user.rb

      git blame: limiting search to a specific folder

    4. $ git log -G "REGEX HERE"

      git blame: searching with a regular expression

    5. Find the entire history of a snippet of code with git log -S Include -p to see the diff as well as the commit messages Include --reverse to see the commit that introduced the code listed first Scope search to specific folders or files by including a path Search with a regular expression using git log -G Search commit messages using git log --grep

      Summary of git blame searching tips

    6. If you include the -p option (short for --patch) you get the full diff alongside the commit messages

      git log -S "method_name" -p <--- get the full dif with commit messages to have more context

    7. Say you want to find the first commit that introduced a particular class, method or snippet of code. You can use the pickaxe combined with the --reverse option to get the commits in reverse-chronological order so the commit where the code first appears is listed at the top

      git log -S "method_name" -p --reverse <--- get commits in reverse-chronological order

    8. git log -S (also known as “the pickaxe”) is how you take things to the next level. It lets you search for all commits that contain a given string:

      git log -S <--- search for commits with a given string

    9. git blame is too coarse: it reports against the whole line. If the most recent change isn’t related to the part of the line you’re interested, you’re out of luck. git blame is too shallow: it only reports a single change; the most recent one. The story of the particular piece of code you’re interested in may have evolved over several commits. git blame is too narrow: it only considers the file you are running blame against. The code you are interested in may also appear in other files, but to get the relevant commits on those you’ll need to run blame several times.

      Disadvantages of git blame command (it's like limiting ourselves to 2D view instead of 3D

  19. Nov 2020
    1. I feel that with all that power that it’s gaining, instead of being a more approachable tool, that it’s actually being a tool that is continuously making people feel frustrated, to the point where I feel that whatever the next version control system is… (And it does not have to be something separate than Git. It should maybe be just a really powerful abstraction built on top of Git.) But I think whatever the next iteration of the people’s version control is… it should be something that is more reflective of how we think about what version control is for us.
    1. master

      une mobilisation parallèle dans le milieu des technologies a eu lieu pour retirer les références à caractère opprimant, mobilisation qui a refait surface avec la poussée du mouvement Black Lives Matter.

      par exemple, une recommandation consiste à nommer «main» ou «primary» la branche principale (au lieu de «master»).

    1. master

      une mobilisation parallèle dans le milieu des technologies a eu lieu pour retirer les références à caractère opprimant, mobilisation qui a refait surface avec la poussée du mouvement Black Lives Matter.

      par exemple, une recommandation consiste à nommer «main» ou «primary» la branche principale (au lieu de «master»).

    1. For example, suppose you want to search for the string "font-size: 52 px;" in your repository: $ git rev-list –all | xargs git grep -F ‘font-size: 52 px;’

      Searching Git repo with grep

    2. $ git show main:README.md Once you execute this command, you can view the content of the file in your terminal.

      You can view the README.md file while being in any branch

    3. Every repository has a .git folder. It is a special hidden folder. $ ls -a . … .git

      Inside the hidden .git folder, you may find:

      1. The current state of HEAD:

      $ cat .git/HEAD ref: refs/heads/master

      1. Potentially a description of your repo:

      $ cat .git/description

    4. To optimize your repository further, you can use Git garbage collection. $ git gc --prune=now --aggressive This command helps when you or your team heavily uses pull or push commands.

      You can optimise your repo not only with .gitignore file, but with Git garbage collection.

      This command is an internal utility that cleans up unreachable or "orphaned" Git objects in your repository

    5. Git, along with some Bash command piping, makes it easy to create a zip archive for your untracked files. $ git ls-files --others --exclude-standard -z |\ xargs -0 tar rvf ~/backup-untracked.zip

      Taking backup of untracked files.

      This command makes an archive (and excludes files listed in .gitignore) with the name backup-untracked.zip

    6. $ git rev-list –count master 32

      Example of counting the number of commits with

      git rev-list --count

    7. Many developers count the number of commits to judge when to increment the build number, for instance, or just to get a feel for how the project is progressing.

      Why to count the number of commits

    8. To avoid similar scenarios, enable Git autocorrection in your Git configuration: $ git config --global help.autocorrect 1

      Applying autocorrection in Git.

      When you type: git stats, instead of suggesting a command, it will run git status automatically

  20. Oct 2020
    1. When you can assume that all the materials you’re using in and with your class are open educational resources, here’s one way to remix the effective practices listed above with OER in order to provide you and your students with opportunities to spend your time and effort on work that makes the world a better place instead of wasting it on disposable assignments.

      As I think of remix, reuse, redistribute and things like git and version control, I also can't help but think that being able to send and receive webmentions in the process of reusing and redistribution with referential links back to the originals will allow the original creator to at least be aware of the changes and their existence to potentially manually add them to the original project. (Manually because they may not (yet) know how to keep their content under source control or allow others to do so and send pull requests.)

    2. Free to accessFree to reuseFree to reviseFree to remixFree to redistributeThe question becomes, then, what is the relationship between these additional capabilities and what we know about effective teaching and learning? How can we extend, revise, and remix our pedagogy based on these additional capabilities?

      I look at this and think immediatly about the Git model of allowing people to not only fork and reuse/redistribute pieces, but what about the ability to do pull requests to take improvements and push them back up the the source so that everyone potentially benefits?

    1. git push origin master explicitly says "push the local branch 'master' to the remote named 'origin'". This does not define a persistent relationship, it just executes a push this one time. Note that the remote branch is assumed to be named "master". git push -u origin master is the same thing, except it first adds a persistent tracking relationship between your local branch "master" and the remote named "origin". As before, it is assumed the remote branch is named "master". If you have done a push with -u already, then the relationship is already defined. In the future, you can simply say git push or git pull, and git will automatically use the defined remote tracking branch without being told explicitly. You can view your tracking relationships with git branch -vv, which will list your local branches along with their current HEAD commit and, if one is set, the remote tracking branch. Here is an example.
  21. Sep 2020
    1. Examining the changes to programs over time is a useful strategy for under-standing the life of the code

      ce que permet notamment le numérique aisément, voire fluidement ou même nativement (avec des logiciels et protocoles comme Git): le versionnement, l'archivage des versions, le marquage volontaire v1, v2 v3.57 comme Kittler…

    1. For a non-monorepo package you can simply point directly to the Github repo. This case is similar, but you want to scope it just to a single package within the repo. For those that make monorepos they don't necessarily need this feature. It's for those that use projects that use monorepos. Telling them to not organize their projects into monorepos doesn't help people who make use of these projects.
    2. If npm installs a git repo, it assumes that the git repo is the package. I don't really know how we could specify a sub-path easily, since all parts of the git url are already used for other things.