git-work | Git minimalist extensions to provide | BPM library

I have an error during the LFS pull with Gitkraken on macOS. I get the following error message:

Error on LFS Pull git: 'lfs' is not a git command. See 'git --help'. The most similar command is log

In the Gitkraken documentation (here) we find the following explanation:

Note: If GitKraken still cannot find Git or Git LFS, the terminal or CMD may be using a different path than the system or user path. For example, on OSX applications launched from the GUI have a different path than those launched from the terminal.

To check this, we can do the following command: which git-lfs and which git

Indeed, I get the following result:

I am new to git/GitHub and am trying to understand and emulate the typical workflow and have run into conflicting advice.

The guidelines for the FirstContributions repository suggest that the typical workflow should be:

fork -> clone -> edit -> pull request

However, the guidelines for the another repository for beginners state the following:

Always clone from the main repository and add your fork as a remote.

Please help me understand the merits of each approach. Which one should I be using?

I use git worktree concept to create multiple working directory. One for each feature and/or bug fix. So I will create a git clone of a repository once, and then I start creating worktree as needed.

When I clone a git repository, by default a working directory is checked out - main worktree. Which we dont use and unnecessarily takes up space. So I am looking for a way to create a git repo with a working directory being checked out at the beginning.

I tried git clone --bare ./test-git

which actually created a git repo without a working directory but I was not able to create a git worktree out of it. I use to throw the following error -

I was getting reports of memory leaks from valgrind in my production code. So, naturally, I narrowed it down to a minimal compilable example. Strange thins is, I had to "minimize it", so much, that there is nothing left except instantiation of a Qt Window!

Is Qt bugged? Did I not invoke valgrind properly?

My tools and versions, from Centos 7:

We have a single git repo with 4 c++ projects which share a lot of source code files. These are our git branches:

• master: used for the main development (currently working on proj2 version 4.x)
• backports/proj1_4.x: branched-out from master when we released the proj1 version 4.0, it contains bugfixes and was used for releasing versions 4.1, 4.2
• backports/proj2_3.x: same for proj2, version 3.x
• backports/proj3_2.x: ...
• backports/proj4_2.x: ...

When we fix a bug in master, we cherry-pick the fix to all backport branches. Having a single clone of the repository means that every time we switch between those branches, lots of c++ object files need to be recompiled.

Existing solutions

• multiple full clones
  • checkout a different branch in each clone.
  • requires a lot of disk space (our .git folder has ~700MB), but avoids switching between branches and therefore also the recompilation of object files. This may be the simplest solution.
• single clone with pre and post checkout git hooks for storing and restoring object files or timestamps of source files: https://stackoverflow.com/a/3195312/1341914
• git worktree
  • use a single .git folder for multiple repository folders.
  • Warning: unusable with submodules as of Q2/2020: https://git-scm.com/docs/git-worktree#_bugs, but I'm not sure what does "Multiple checkout" mean.
• ccache
  • when working on master for a long time, the cache dir may contain only object files from master, because the older object files from backport branches didn't fit in the ccache storage limit.
• full clone of master + shallow clones of backport branches
  • how would we cherry-pick a commit when the clone has just depth 1? The commit SHA1 wouldn't be found in the shallow clone, but we could export the commit as a patch file and then apply it to the shallow clone
• shared / reference
  • git clone --reference DIR GIT_REPO_URL or git clone --shared DIR
  • because the parent repo doesn't know about its other clones, when an object is removed in the main repo, it may become unreferenced in the child repo, potentially corrupting the child repo.

What would you recommend? Is there any other/better solution?

OS: Ubuntu 19.10
git: 2.20.1

I just spend a lot of time writing up some documentation. I saved the markdown file in my documentation site's project folder as: content/topics/workflow/docker/git-workflow.md

As a personal exercise, I am writing a command line and git-based issue tracker where the issues are saved in another git branch (say, project-issues). Let's say I'm currently working on the master branch. With my issue tracker, running issue-tracker --add-issue "Fix all bugs" will need to modify the contents of the project-issues branch. So the question is: what is a recommended way to programmatically modify the contents of another branch (even if there are uncommited changes in the current branch)?

Possible methods I've thought of:

• The program runs git stash on the branch that the user is working on, switches to the project-issues branch, makes the required commits to the project-issues branch, switches back to the branch that the user was originally on, then runs git stash apply.
• The program creates a temporary working directory for the project-issues branch using git-workdir, makes the required commits in the temporary working directory, then deletes the temporary working directory.

Is there a simpler solution to this problem?

P.S. The program is written in Python.

I have a simple repository and I need to have a branch checked out in a different directory. For that I use git worktree. Normally git worktree add -B hello ../hello master creates a new branch called hello from master and checks it out under ../hello.

That is actually exactly what I am looking for, except for that the directory already exists. According to the documentation -B is supposed to ignore that and just use the files that are in the directory, but it still complains with:

I have a ~/scripts/git-workflow.sh file that looks like: