Op werkdagen voor 23:00 besteld, morgen in huis Gratis verzending vanaf €20
,

Version Control with Git

Powerful Tools and Techniques for Collaborative Software Developement

Paperback Engels 2022 9781492091196
Verkooppositie 3195Hoogste positie: 3195
Verwachte levertijd ongeveer 8 werkdagen

Samenvatting

Track, branch, merge, and manage code revisions with Git, the free and open source distributed version control system. Through a series of step-by-step tutorials, this practical guide quickly takes you from Git fundamentals to advanced techniques, and provides friendly yet rigorous advice for navigating Git's many functions. You'll learn how to work with everything from small to very large projects with speed and efficiency.

In this third edition, authors Prem Kumar Ponuthorai and Jon Loeliger break down Git concepts using a modular approach. You'll start with the basics and fundamental philosophy of Git, followed by intermediate commands to help you efficiently supplement your daily development workflow. Finally, you'll learn advanced Git commands and concepts to understand how Git works under the hood.

- Learn how to use Git for real-world development scenarios
- Gain insight into Git's common use cases, initial tasks, and basic functions
- Use the system for distributed version control
- Learn how to manage merges, conflicts, patches, and diffs
- Apply advanced techniques such as rebasing, hooks, and ways to handle submodules

Specificaties

ISBN13:9781492091196
Taal:Engels
Bindwijze:paperback
Aantal pagina's:545
Uitgever:O'Reilly
Druk:3
Verschijningsdatum:30-11-2022
Hoofdrubriek:IT-management / ICT
ISSN:

Lezersrecensies

Wees de eerste die een lezersrecensie schrijft!

Geef uw waardering

Zeer goed Goed Voldoende Matig Slecht

Over Jon Loeliger

Jon Loeliger is a freelance software engineer who contributes to Open Source projects such as Linux, U-Boot, and Git. He has given tutorial presentations on Git at many conferences including Linux World, and has written several papers on Git for Linux Magazine. In prior lives, Jon has spent a number of years developing highly optimizing compilers, router protocols, Linux porting, and the occasional game. Jon holds degrees in Computer Science from Purdue University. In his spare time, he is a home winemaker.

Andere boeken door Jon Loeliger

Over Matthew McCullough

Matthew McCullough is an energetic 15 year veteran of enterprise software development, open source education, and co-founder of Ambient Ideas, LLC, a Denver consultancy. Matthew currently is a trainer for GitHub.com, author of the Git Master Class series for O'Reilly, speaker at over 200 events, 30 national and international conferences, author of three of the top 10 DZone RefCards, and President of the Denver Open Source Users Group. His current topics of research center around project automation: build tools (Maven, Leiningen, Gradle), distributed version control (Git), Continuous Integration (Jenkins, Hudson) and Quality Metrics (Sonar). Matthew resides in Denver, Colorado with his beautiful wife and two young daughters, who are active in nearly every outdoor activity Colorado has to offer.

Andere boeken door Matthew McCullough

Inhoudsopgave

Preface
Who This Book Is For
Essential Know-How
New in This Revision
Navigating the Book
Installing Git
A Note on Inclusive Language
Omissions
Conventions Used in This Book
O'Reilly Online Learning
How to Contact Us
Acknowledgments
Attributions

Part I. Thinking in Git
1. Introduction to Git
Git Components
Git Characteristics
The Git Command Line
Quick Introduction to Using Git
Preparing to Work with Git
Working with a Local Repository
Working with a Shared Repository
Configuration Files
Summary

2. Foundational Concepts
Repositories
Git Object Store
Index
Content-Addressable Database
Git Tracks Content
Pathname Versus Content
Packfiles
Visualizing the Git Object Store
Git Internals: Concepts at Work
Inside the .git Directory
Blob Objects and Hashes
Tree Object and Files
A Note on Git’s Use of SHA1
Tree Hierarchies
Commit Objects
Tag Objects
Summary

Part II. Fundamentals of Git
3. Branches
Motivation for Using Branches in Git
Branching Guidelines
Branch Names
Dos and Don'ts in Branch Names
Managing Branches
Working in Branches
Creating Branches
Listing Branch Names
Viewing Branches and Their Commits
Switching (Checking Out) Branches
Merging Changes into a Different Branch
Creating and Checking Out a New Branch
Detached HEAD
Deleting Branches
Summary

4. Commits
Commits: Recorded Units of Change
Atomic Changesets
Identifying Commits
Absolute Commit Names
Refs and Symrefs
Relative Commit Names
Commit History
Viewing Old Commits
Commit Graphs
Commit Ranges
Summary

5. File Management and the Index
Importance of the Index
File Classifications in Git
Using git add
Notes on Using git commit
Using git commit --all
Writing Commit Log Messages
Using git rm
Using git mv
A Note on Tracking Renames
The .gitignore File
Summary

6. Merges
Merge: A Technical View
Merge Examples
Preparing for a Merge
Merging Two Branches
A Merge with a Conflict
Working with Merge Conflicts
Locating Conflicted Files
Inspecting Conflicts
How Git Keeps Track of Conflicts
Finishing Up a Conflict Resolution
Aborting or Restarting a Merge
Merge Strategies
Degenerate Merges
Normal Merges
Specialty Merges
Applying Merge Strategies
Merge Drivers
How Git Thinks About Merges
Merges and Git's Object Model
Squash Merges
Why Not Just Merge Each Change One by One?
Summary

7. Diffs
Forms of the git diff Command
Simple git diff Example
Understanding the git diff Output
git diff and Commit Ranges
git diff with Path Limiting
How Git Derives diffs
Summary

Part III. Intermediate Skills
8. Finding Commits
Using git bisect
Using git blame
Using Pickaxe
Summary

9. Altering Commits
Philosophy of Altering Commit History
Caution About Altering History
Using git revert
Changing the HEAD Commit
Using git reset
Using git cherry-pick
reset, revert, and checkout
Rebasing Commits
Using git rebase -i
rebase Versus merge
Summary

10. The Stash and the Reflog
The Stash
Use Case: Interrupted Workflow
Use Case: Updating Local Work in Progress with Upstream Changes
Use Case: Converting Stashed Changes Into a Branch
The Reflog
Summary

11. Remote Repositories
Part I: Repository Concepts
Bare and Development Repositories
Repository Clones
Remotes
Tracking Branches
Referencing Other Repositories
Referring to Remote Repositories
The refspec

Part II: Example Using Remote Repositories
Creating an Authoritative Repository
Make Your Own Origin Remote
Developing in Your Repository
Pushing Your Changes
Adding a New Developer
Getting Repository Updates

Part III: Remote Repository Development Cycle in Pictures
Cloning a Repository
Alternate Histories
Non-Fast-Forward Pushes
Fetching the Alternate History
Merging Histories
Merge Conflicts
Pushing a Merged History

Part IV: Remote Configuration
Using git remote
Using git config
Using Manual Editing
Part V: Working with Tracking Branches
Creating Tracking Branches
Ahead and Behind
Adding and Deleting Remote Branches
Bare Repositories and git push
Summary

12. Repository Management
Publishing Repositories
Repositories with Controlled Access
Repositories with Anonymous Read Access
Repositories with Anonymous Write Access
Repository Publishing Advice
Repository Structure
Shared Repository Structure
Distributed Repository Structure
Living with Distributed Development
Changing Public History
Separate Commit and Publish Steps
No One True History
Knowing Your Place
Upstream and Downstream Flows
The Maintainer and Developer Roles
Maintainer–Developer Interaction
Role Duality
Working with Multiple Repositories
Your Own Workspace
Where to Start Your Repository
Converting to a Different Upstream Repository
Using Multiple Upstream Repositories
Forking Projects
Summary

Part IV. Advanced Skills
13. Patches
Why Use Patches?
Generating Patches
Patches and Topological Sorts
Mailing Patches
Applying Patches
Bad Patches
Patching Versus Merging
Summary

14. Hooks
Types of Hooks
A Note on Using Hooks
Installing Hooks
Example Hooks
Creating Your First Hook
Available Hooks
Commit-Related Hooks
Patch-Related Hooks
Push-Related Hooks
Other Local Repository Hooks
To Hook or Not
Summary

15. Submodules
Gitlinks
Submodules
Why Submodules?
Working with Submodules
Submodules and Credential Reuse
Git Subtrees
Adding a Subproject
Pulling Subproject Updates
Changing the Subproject from Within the Superproject
Git Submodule and Subtree Visual Comparison
Summary

16. Advanced Manipulations
Interactive Hunk Staging
Loving git rev-list
Date-Based Checkout
Retrieve an Old Version of a File
Recovering a Lost Commit
The git fsck Command
Reconnecting a Lost Commit
Using git filter-repo
Examples Using git filter-repo
Summary

Part V. Tips and Tricks
17. Tips, Tricks, and Techniques
Interactive Rebase with a Dirty Working Directory
Garbage Collection
Tips for Recovering Commits
Recovering from an Upstream Rebase
Quick Overview of Changes
Cleaning Up
Using git-grep to Search a Repository
Updating and Deleting refs
Following Files That Moved
Have You Been Here Before?
Migrating to Git
Migrating from a Git Version Control System
Migrating from a Non-Git Version Control System
A Note on Working with Large Repositories
Git LFS
Repository Before Git LFS and After Git LFS
Installing Git LFS
Tracking Large Objects with Git LFS
Useful Git LFS Techniques
Converting Existing Repositories to Use Git LFS
Summary

18. Git and GitHub
About GitHub
Types of GitHub Accounts
GitHub in the Git Ecosystem
Hosting a Repository in GitHub
Repository View
Code
Issues
Pull Requests
The GitHub Flow
Resolving Merge Conflicts in GitHub
Development Workflows
Integrating with GitHub
Summary

A. History of Git
The Birth of Git
Precedents
Timeline
What's in a Name?

B. Installing Git
Using Linux Binary Distributions
Debian/Ubuntu
Other Binary Distributions
Installing Git on macOS
Installing Git on Windows
Obtaining a Source Release
Building and Installing from Source Release

Index
About the Author

Managementboek Top 100

Rubrieken

Populaire producten

    Personen

      Trefwoorden

        Version Control with Git