BestCloudHostingASP.NET | Best and affordable Git 2.28.0 hosting.

What is Git?

Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Git is easy to learn and has a tiny footprint with lightning fast performance. It outclasses SCM tools like Subversion, CVS, Perforce, and ClearCase with features like cheap local branching, convenient staging areas, and multiple workflows.

What’s New on Git 2.28.0?

Git 2.28 Release Notes
======================

Updates since v2.27
-------------------

Backward compatibility notes

 * "fetch.writeCommitGraph" is deemed to be still a bit too risky and
   is no longer part of the "feature.experimental" set.


UI, Workflows & Features

 * The commands in the "diff" family learned to honor "diff.relative"
   configuration variable.

 * The check in "git fsck" to ensure that the tree objects are sorted
   still had corner cases it missed unsorted entries.

 * The interface to redact sensitive information in the trace output
   has been simplified.

 * The command line completion (in contrib/) learned to complete
   options that the "git switch" command takes.

 * "git diff" used to take arguments in random and nonsense range
   notation, e.g. "git diff A..B C", "git diff A..B C...D", etc.,
   which has been cleaned up.

 * "git diff-files" has been taught to say paths that are marked as
   intent-to-add are new files, not modified from an empty blob.

 * "git status" learned to report the status of sparse checkout.

 * "git difftool" has trouble dealing with paths added to the index
   with the intent-to-add bit.

 * "git fast-export --anonymize" learned to take customized mapping to
   allow its users to tweak its output more usable for debugging.

 * The command line completion support (in contrib/) used to be
   prepared to work with "set -u" but recent changes got a bit more
   sloppy.  This has been corrected.

 * "git gui" now allows opening work trees from the start-up dialog.


Performance, Internal Implementation, Development Support etc.

 * Code optimization for a common case.
   (merge 8777616e4d an/merge-single-strategy-optim later to maint).

 * We've adopted a convention that any on-stack structure can be
   initialized to have zero values in all fields with "= { 0 }",
   even when the first field happens to be a pointer, but sparse
   complained that a null pointer should be spelled NULL for a long
   time.  Start using -Wno-universal-initializer option to squelch
   it (the latest sparse has it on by default).

 * "git log -L..." now takes advantage of the "which paths are touched
   by this commit?" info stored in the commit-graph system.

 * As FreeBSD is not the only platform whose regexp library reports
   a REG_ILLSEQ error when fed invalid UTF-8, add logic to detect that
   automatically and skip the affected tests.

 * "git bugreport" learns to report what shell is in use.

 * Support for GIT_CURL_VERBOSE has been rewritten in terms of
   GIT_TRACE_CURL.

 * Preliminary clean-ups around refs API, plus file format
   specification documentation for the reftable backend.

 * Workaround breakage in MSVC build, where "curl-config --cflags"
   gives settings appropriate for GCC build.

 * Code clean-up of "git clean" resulted in a fix of recent
   performance regression.

 * Code clean-up in the codepath that serves "git fetch" continues.

 * "git merge-base --is-ancestor" is taught to take advantage of the
   commit graph.

 * Rewrite of parts of the scripted "git submodule" Porcelain command
   continues; this time it is "git submodule set-branch" subcommand's
   turn.

 * The "fetch/clone" protocol has been updated to allow the server to
   instruct the clients to grab pre-packaged packfile(s) in addition
   to the packed object data coming over the wire.

 * A misdesigned strbuf_write_fd() function has been retired.

 * SHA-256 migration work continues, including CVS/SVN interface.

 * A few fields in "struct commit" that do not have to always be
   present have been moved to commit slabs.

 * API cleanup for get_worktrees()

 * By renumbering object flag bits, "struct object" managed to lose
   bloated inter-field padding.

 * The name of the primary branch in existing repositories, and the
   default name used for the first branch in newly created
   repositories, is made configurable, so that we can eventually wean
   ourselves off of the hardcoded 'master'.

 * The effort to avoid using test_must_fail on non-git command continues.

 * In 2.28-rc0, we corrected a bug that some repository extensions are
   honored by mistake even in a version 0 repositories (these
   configuration variables in extensions.* namespace were supposed to
   have special meaning in repositories whose version numbers are 1 or
   higher), but this was a bit too big a change.  The behaviour in
   recent versions of Git where certain extensions.* were honored by
   mistake even in version 0 repositories has been restored.


Fixes since v2.27
-----------------

 * The "--prepare-p4-only" option of "git p4" is supposed to stop
   after replaying one changeset, but kept going (by mistake?)

 * The error message from "git checkout -b foo -t bar baz" was
   confusing.

 * Some repositories in the wild have commits that record nonsense
   committer timezone (e.g. rails.git); "git fast-import" learned an
   option to pass these nonsense timestamps intact to allow recreating
   existing repositories as-is.
   (merge d42a2fb72f en/fast-import-looser-date later to maint).

 * The command line completion script (in contrib/) tried to complete
   "git stash -p" as if it were "git stash push -p", but it was too
   aggressive and also affected "git stash show -p", which has been
   corrected.
   (merge fffd0cf520 vs/complete-stash-show-p-fix later to maint).

 * On-the-wire protocol v2 easily falls into a deadlock between the
   remote-curl helper and the fetch-pack process when the server side
   prematurely throws an error and disconnects.  The communication has
   been updated to make it more robust.

 * "git checkout -p" did not handle a newly added path at all.
   (merge 2c8bd8471a js/checkout-p-new-file later to maint).

 * The code to parse "git bisect start" command line was lax in
   validating the arguments.
   (merge 4d9005ff5d cb/bisect-helper-parser-fix later to maint).

 * Reduce memory usage during "diff --quiet" in a worktree with too
   many stat-unmatched paths.
   (merge d2d7fbe129 jk/diff-memuse-optim-with-stat-unmatch later to maint).

 * The reflog entries for "git clone" and "git fetch" did not
   anonymize the URL they operated on.
   (merge 46da295a77 js/reflog-anonymize-for-clone-and-fetch later to maint).

 * The behaviour of "sparse-checkout" in the state "git clone
   --no-checkout" left was changed accidentally in 2.27, which has
   been corrected.

 * Use of negative pathspec, while collecting paths including
   untracked ones in the working tree, was broken.

 * The same worktree directory must be registered only once, but
   "git worktree move" allowed this invariant to be violated, which
   has been corrected.
   (merge 810382ed37 es/worktree-duplicate-paths later to maint).

 * The effect of sparse checkout settings on submodules is documented.
   (merge e7d7c73249 en/sparse-with-submodule-doc later to maint).

 * Code clean-up around "git branch" with a minor bugfix.
   (merge dc44639904 dl/branch-cleanup later to maint).

 * A branch name used in a test has been clarified to match what is
   going on.
   (merge 08dc26061f pb/t4014-unslave later to maint).

 * An in-code comment in "git diff" has been updated.
   (merge c592fd4c83 dl/diff-usage-comment-update later to maint).

 * The documentation and some tests have been adjusted for the recent
   renaming of "pu" branch to "seen".
   (merge 6dca5dbf93 js/pu-to-seen later to maint).

 * The code to push changes over "dumb" HTTP had a bad interaction
   with the commit reachability code due to incorrect allocation of
   object flag bits, which has been corrected.
   (merge 64472d15e9 bc/http-push-flagsfix later to maint).

 * "git send-email --in-reply-to=<msg>" did not use the In-Reply-To:
   header with the value given from the command line, and let it be
   overridden by the value on In-Reply-To: header in the messages
   being sent out (if exists).
   (merge f9f60d7066 ra/send-email-in-reply-to-from-command-line-wins later to maint).

 * "git log -Lx,y:path --before=date" lost track of where the range
   should be because it didn't take the changes made by the youngest
   commits that are omitted from the output into account.

 * When "fetch.writeCommitGraph" configuration is set in a shallow
   repository and a fetch moves the shallow boundary, we wrote out
   broken commit-graph files that do not match the reality, which has
   been corrected.

 * "git checkout" failed to catch an error from fstat() after updating
   a path in the working tree.
   (merge 35e6e212fd mt/entry-fstat-fallback-fix later to maint).

 * When an aliased command, whose output is piped to a pager by git,
   gets killed by a signal, the pager got into a funny state, which
   has been corrected (again).
   (merge c0d73a59c9 ta/wait-on-aliased-commands-upon-signal later to maint).

 * The code to produce progress output from "git commit-graph --write"
   had a few breakages, which have been fixed.

 * Other code cleanup, docfix, build fix, etc.
   (merge 2c31a7aa44 jx/pkt-line-doc-count-fix later to maint).
   (merge d63ae31962 cb/t5608-cleanup later to maint).
   (merge 788db145c7 dl/t-readme-spell-git-correctly later to maint).
   (merge 45a87a83bb dl/python-2.7-is-the-floor-version later to maint).
   (merge b75a219904 es/advertise-contribution-doc later to maint).
   (merge 0c9a4f638a rs/pull-leakfix later to maint).
   (merge d546fe2874 rs/commit-reach-leakfix later to maint).
   (merge 087bf5409c mk/pb-pretty-email-without-domain-part-fix later to maint).
   (merge 5f4ee57ad9 es/worktree-code-cleanup later to maint).
   (merge 0172f7834a cc/cat-file-usage-update later to maint).
   (merge 81de0c01cf ma/rebase-doc-typofix later to maint).

Branching and Merging

The Git feature that really makes it stand apart from nearly every other SCM out there is its branching model.

Git allows and encourages you to have multiple local branches that can be entirely independent of each other. The creation, merging, and deletion of those lines of development takes seconds.

This means that you can do things like:

• Frictionless Context Switching. Create a branch to try out an idea, commit a few times, switch back to where you branched from, apply a patch, switch back to where you are experimenting, and merge it in.
• Role-Based Codelines. Have a branch that always contains only what goes to production, another that you merge work into for testing, and several smaller ones for day to day work.
• Feature Based Workflow. Create new branches for each new feature you’re working on so you can seamlessly switch back and forth between them, then delete each branch when that feature gets merged into your main line.
• Disposable Experimentation. Create a branch to experiment in, realize it’s not going to work, and just delete it – abandoning the work—with nobody else ever seeing it (even if you’ve pushed other branches in the meantime).

Small and Fast

Git is fast. With Git, nearly all operations are performed locally, giving it a huge speed advantage on centralized systems that constantly have to communicate with a server somewhere.

Git was built to work on the Linux kernel, meaning that it has had to effectively handle large repositories from day one. Git is written in C, reducing the overhead of runtimes associated with higher-level languages. Speed and performance has been a primary design goal of the Git from the start.

Benchmarks

Let’s see how common operations stack up against Subversion, a common centralized version control system that is similar to CVS or Perforce. Smaller is faster.

Distributed

One of the nicest features of any Distributed SCM, Git included, is that it’s distributed. This means that instead of doing a “checkout” of the current tip of the source code, you do a “clone” of the entire repository.

Multiple Backups

This means that even if you’re using a centralized workflow, every user essentially has a full backup of the main server. Each of these copies could be pushed up to replace the main server in the event of a crash or corruption. In effect, there is no single point of failure with Git unless there is only a single copy of the repository.

Any Workflow

Because of Git’s distributed nature and superb branching system, an almost endless number of workflows can be implemented with relative ease.

Subversion-Style Workflow

A centralized workflow is very common, especially from people transitioning from a centralized system. Git will not allow you to push if someone has pushed since the last time you fetched, so a centralized model where all developers push to the same server works just fine.

Data Assurance

The data model that Git uses ensures the cryptographic integrity of every bit of your project. Every file and commit is checksummed and retrieved by its checksum when checked back out. It’s impossible to get anything out of Git other than the exact bits you put in.

Staging Area

Unlike the other systems, Git has something called the “staging area” or “index”. This is an intermediate area where commits can be formatted and reviewed before completing the commit.

One thing that sets Git apart from other tools is that it’s possible to quickly stage some of your files and commit them without committing all of the other modified files in your working directory or having to list them on the command line during the commit.

Free and Open Source

Git is released under the GNU General Public License version 2.0, which is an open source license. The Git project chose to use GPLv2 to guarantee your freedom to share and change free software—to make sure the software is free for all its users.