Mastering Git : Attain Expert-Level Proficiency with Git by Mastering Distributed Version Control Features / Jakub Narebski.

Format:

Book

Author/Creator:

Narebski, Jakub, author.

Language:

English

Subjects (All):

Git (Computer file).

Revision control (Computer science).

Open source software.

Computer software--Development--Management.

Computer software.

Software engineering--Management.

Software engineering.

Physical Description:

1 online resource (444 pages)

Edition:

Second edition.

Place of Publication:

Birmingham : Packt Publishing, [2024]

System Details:

Mode of access: World Wide Web.

Biography/History:

Narebski Jakub: Jakub Narebski followed Git development from the very beginning of its creation. He created, announced, and analyzed the annual Git User's Surveys from 2007 till 2012 all except the first one (you can find his analysis of those surveys on the Git wiki). He shares his expertise in the technology on the StackOverflow question-and-answer site. He is one of the editors of Git Rev News, which is a monthly digest of all things Git. He is an assistant professor in the Faculty of Mathematics and Computer Science at the Nicolaus Copernicus University in Torun, Poland. He uses Git as his version control system of choice both for personal and professional work and teaches it to computer science students as a part of their coursework. Jakub Narebski was one of the proofreaders of the Version Control by Example book by Eric Sink, and was the reason why it has a chapter on Git.

Summary:

Developers often feel overwhelmed by complex version control issues, especially when managing large repositories. This updated second edition of our Git guide empowers you to tackle these challenges head-on and emerge as a Git pro. The book gets you up to speed with the latest Git version, its features, and advanced branching techniques, helping you master complex development scenarios. A new chapter on tackling challenges while managing large repositories has been added, providing invaluable strategies for efficient version control with Git. The book goes beyond the basics to take you through Git’s architecture, behavior, and best practices in depth. The chapters help you develop a clear understanding of customizing workflows, creating unique solutions, and tackling any version control hurdle. As you advance, you’ll explore a wide range of functionalities, from examining project history to collaborating seamlessly with teammates. Detailed descriptions guide you through managing your work, collaborating with others, administering Git, and navigating project history. By the end of this book, you’ll have become a Git pro and be confident enough to handle advanced branching, manage large repositories, customize workflows, collaborate effectively, and troubleshoot any version control issues.

Contents:

Cover

Title Page

Copyright and Credits

Contributors

Table of Contents

Preface

Part 1 - Exploring Project History and Managing Your Own Work

Chapter 1: Git Basics in Practice

Technical requirements

A brief introduction to version control and Git

Git by example

Setup and initialization

Collaborative development

Branching and merging

Summary

Questions

Answers

Further reading

Chapter 2: Developing with Git

Creating a new commit

How a new commit extends a project's history

The index - a staging area for commits

Examining the changes to be committed

Selective commit

Amending a commit

Working with branches and tags

Creating a new branch

Creating orphan branches

Selecting and switching to a branch

Listing branches and tags

Rewinding or resetting a branch

Deleting a branch

Changing the branch name

Chapter 3: Managing Your Worktrees

Ignoring files

Marking files as intentionally untracked (ignored)

Which types of files should be ignored?

Listing ignored files

Trick - ignoring changes in tracked files

File attributes

Identifying binary files and end-of-line conversions

Diff and merge configuration

Transforming files (content filtering)

Keyword expansion and substitution

Other built-in attributes

Defining attribute macros

Fixing mistakes with the reset command

Rewinding the branch head, softly

Resetting the branch head and the index

Discarding changes and rewinding the branch

Safer reset - keeping your changes

Stashing away your changes

Using git stash

Stash and the staging area

Stash internals

Managing worktrees and the staging area

Examining files and directories

Searching file contents.

Un-tracking, un-staging, and un-modifying files

Resetting a file to the old version

Cleaning the working area

Multiple working directories

Chapter 4: Exploring Project History

DAGs

Whole-tree commits

Branches and tags

Branch points

Merge commits

Single revision selection

HEAD - the implicit revision

Branch and tag references

The

branches,

tags, and similar options

SHA-1 and the shortened SHA-1 identifier

Ancestry references

Reverse ancestry references - git-describe output

Reflogging shortnames

Upstreaming remote-tracking branches

Selecting revisions via a commit message

Selecting the revision range

Single revision as a revision range

Double-dot notation

Creating the range by including and excluding revisions

The revision range for a single revision

Triple-dot notation

Chapter 5: Searching Through the Repository

Searching the history

Limiting the number of revisions

Matching revision metadata

Searching changes in revisions

Selecting types of changes

History of a file

Path limiting

History simplification

Blame - the line-wise history of a file

Finding bugs with git bisect

Starting the git bisect process

Finding the buggy commit

Automating testing during the git bisect process

Selecting and formatting the git log output

Predefined and user-defined output formats

Including, formatting, and summing up changes

Summarizing contributions

Mapping authors

Viewing a revision and a file at revision

Part 2 - Working with Other Developers

Chapter 6: Collaborative Development with Git

Collaborative workflows

Bare repositories.

Interacting with other repositories

The centralized workflow

The peer-to-peer or forking workflow

The maintainer or integration manager workflow

The hierarchical or dictator-and-lieutenants workflow

Managing remote repositories

The "origin" remote

Listing and examining remotes

Adding a new remote

Updating information about remotes

Support for triangular workflows

Chain of trust

Content-addressed storage

Lightweight, annotated, and signed tags

Signed commits

Merging signed tags (merge tags)

Chapter 7: Publishing Your Changes

Transport protocols and remote helpers

Local transport

Smart transports

Legacy (dumb) transports

Offline transport with bundles

Remote transport helpers

Credentials/password management

Publishing your changes upstream

Pushing to a public repository

Generating a pull request

Exchanging patches

Chapter 8: Advanced Branching Techniques

The purpose of branching

Isolation versus integration

The path to production release

Long-running and short-lived branches

Visibility of branches

Alternatives to branching

Visibility without integration

Branching patterns

Integration patterns

Release engineering

Other branching patterns involving long-lived branches

Other types of short-lived branches

Branching workflows and release engineering

The release and trunk branches workflow

The graduation branches workflow

The topic branches workflow

git-flow - a successful Git branching model

Ship/Show/Ask - a modern branching strategy

Fixing a security issue

Interacting with branches in remote repositories

Upstream and downstream

Remote-tracking branches and refspec

Fetching and pulling versus pushing.

Fetching and pushing branches and tags

Push modes and their use

Chapter 9: Merging Changes Together

Methods of combining changes

Merging branches

Copying and applying a changeset

Rebasing a branch

Squash merge

Resolving merge conflicts

The three-way merge

Examining failed merges

Avoiding merge conflicts

Dealing with merge conflicts

Chapter 10: Keeping History Clean

An introduction to Git internals

Git objects

Plumbing and porcelain Git commands

Rewriting history

Amending the last commit

The interactive rebase

External tools - patching management interfaces

Rewriting project history with Git filter-repo

External tools for large-scale history rewriting

The perils of rewriting published history

Amending history without rewriting

Reverting a commit

Storing additional information with notes

Using git replace

Part 3 - Managing, Configuring, and Extending Git

Chapter 11: Managing Subprojects

Building a living framework

Managing dependencies outside of Git

Manually importing the code into your project

A Git subtree solution for embedding the subproject code

Creating a remote for a subproject

Adding a subproject as a subtree

Cloning and updating superprojects with subtrees

Getting updates from subprojects with a subtree merge

Showing changes between a subtree and its upstream

Sending changes to the upstream of a subtree

The Git submodules solution - a repository inside a repository

Gitlinks, .git files, and the git submodule command

Adding a subproject as a submodule

Cloning superprojects with submodules

Updating submodules after superproject changes.

Examining changes in a submodule

Getting updates from the upstream of the submodule

Sending submodule changes upstream

Transforming a subfolder into a subtree or submodule

Subtrees versus submodules

Use cases for subtrees

Use cases for monorepo

Use cases for submodules

Third-party subproject management solutions

Chapter 12: Managing Large Repositories

Scalar - Git at scale for everyone

Handling repositories with a very long history

Using shallow clones to get truncated history

Cloning only a single branch

Making operations faster in repositories with a long history

Handling repositories with large binary files

Splitting the binary asset folder into a separate submodule

Storing large binary files outside the repository

Handling repositories with a large number of files

Limiting the number of working directory files with sparse checkout

Reducing the local repository size with sparse clone

Faster checking for file changes with filesystem monitor

Chapter 13: Customizing and Extending Git

Git on the command line

Git-aware command prompt

Command-line completion for Git

Autocorrection for Git commands

Making the command line prettier

Alternative command line

Graphical interfaces

Types of graphical tools

Graphical diff and merge tools

Graphical interface examples

Configuring Git

Command-line options and environment variables

Git configuration files

Per-file configuration with gitattributes

Automating Git with hooks

Installing a Git hook

A template for repositories

Client-side hooks

Server-side hooks

Extending Git

Command aliases for Git

Adding new Git commands

Credential helpers and remote helpers

Summary.

Questions.

Notes:

Includes bibliographical references and index.

Description based on publisher supplied metadata and other sources.

Description based on print version record.

Other Format:

Print version: Narębski, Jakub Mastering Git

ISBN:

9781835080054

OCLC:

1454574509