Preface
by Jakub Narębski, Rasmus Voss, Aske Olsson, Ferdinando Santacroce
Git: Mastering Version Control
- Git: Mastering Version Control
- Table of Contents
- Git: Mastering Version Control
- Git: Mastering Version Control
- Credits
- Preface
- I. Module 1
- 1. Getting Started with Git
- 2. Git Fundamentals – Working Locally
- 3. Git Fundamentals – Working Remotely
- 4. Git Fundamentals – Niche Concepts, Configurations, and Commands
- Dissecting the Git configuration
- Configuration architecture
- Configuration levels
- Listing configurations
- Editing configuration files manually
- Setting up other environment configurations
- Basic configurations
- 5. Obtaining the Most – Good Commits and Workflows
- The art of committing
- Adopting a workflow – a wise act
- Summary
- 6. Migrating to Git
- 7. Git Resources
- II. Module 2
- 1. Navigating Git
- 2. Configuration
- 3. Branching, Merging, and Options
- 4. Rebase Regularly and Interactively, and Other Use Cases
- 5. Storing Additional Information in Your Repository
- 6. Extracting Data from the Repository
- 7. Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts
- Introduction
- Using a branch description in the commit message
- Creating a dynamic commit message template
- Using external information in the commit message
- Preventing the push of specific commits
- Configuring and using Git aliases
- Configuring and using Git scripts
- Setting up and using a commit template
- 8. Recovering from Mistakes
- Introduction
- Undo – remove a commit completely
- Undo – remove a commit and retain the changes to files
- Undo – remove a commit and retain the changes in the staging area
- Undo – working with a dirty area
- Redo – recreate the latest commit with new changes
- Revert – undo the changes introduced by a commit
- Reverting a merge
- Viewing past Git actions with git reflog
- Finding lost changes with git fsck
- 9. Repository Maintenance
- Introduction
- Pruning remote branches
- Running garbage collection manually
- Turning off automatic garbage collection
- Splitting a repository
- Rewriting history – changing a single file
- Back up your repositories as mirror repositories
- A quick submodule how-to
- Subtree merging
- Submodule versus subtree merging
- 10. Patching and Offline Sharing
- 11. Git Plumbing and Attributes
- Introduction
- Displaying the repository information
- Displaying the tree information
- Displaying the file information
- Writing a blob object to the database
- Writing a tree object to the database
- Writing a commit object to the database
- Keyword expansion with attribute filters
- Metadata diff of binary files
- Storing binaries elsewhere
- Checking the attributes of a file
- Attributes to export an archive
- 12. Tips and Tricks
- III. Module 3
- 1. Git Basics in Practice
- An introduction to version control and Git
- Git by example
- Repository setup
- Creating a Git repository
- Cloning the repository and creating the first commit
- Publishing changes
- Examining history and viewing changes
- Renaming and moving files
- Updating your repository (with merge)
- Creating a tag
- Resolving a merge conflict
- Adding files in bulk and removing files
- Undoing changes to a file
- Creating a new branch
- Merging a branch (no conflicts)
- Undoing an unpublished merge
- Summary
- 2. Exploring Project History
- 3. Developing with Git
- 4. Managing Your Worktree
- Ignoring files
- File attributes
- Fixing mistakes with the reset command
- Stashing away your changes
- Managing worktrees and the staging area
- Multiple working directories
- Summary
- 5. Collaborative Development with Git
- 6. Advanced Branching Techniques
- Types and purposes of branches
- Branching workflows and release engineering
- Interacting with branches in remote repositories
- Summary
- 7. Merging Changes Together
- 8. Keeping History Clean
- An introduction to Git internals
- Rewriting history
- Amending history without rewriting
- Summary
- 9. Managing Subprojects – Building a Living Framework
- Managing library and framework dependencies
- Managing large Git repositories
- Summary
- 10. Customizing and Extending Git
- 11. Git Administration
- 12. Git Best Practices
- 1. Git Basics in Practice
- A. Bibliography
- Index
- Configuration architecture
- Dissecting the Git configuration
Git is the clear leader in the new paradigm of distributed version control systems. Originally developed by Linus Torvalds as a source control management (SCM) system for the Linux kernel to replace the proprietary SCM BitKeeper, Git has since conquered most of the open source world and is also used by lots of organizations for their private/proprietary projects.
If you are reading this course, you are probably a software developer and a professional. What makes a good professional? Sure, culture and experience are a part of the answer, but there's more: a good professional is one who can master different tools, choose the best tool for the job at hand, and has the necessary discipline to develop good working habits.
Version control is one of the base skills for developers and Git is one of the right tools for the job. However, Git can't be compared to a screwdriver, a simple tool with only a basic function; Git provides a complete toolbox that can help you manage your own code, within which there are also other sharp tools that should be handled with caution.
The aim of this course is to help you to start using Git and its commands in the safest way possible, to get things done without causing any injuries. Having said this, you will not get the most from Git commands if you do not acquire the right habits; just as is the case with other tools, in the end, it is the craftsman who makes all the difference. This course is meticulously designed to help you gain deeper insights into Git's architecture and its underlying concepts, behavior, and best practices.
Module 1, Git Essentials, cover all the basic topics of Git, thereby letting you start using it even if you have little or no experience with versioning systems. It starts off with the installation and do your first commit. You will learn how to manage and organize code, remotely work with repositories, and few basic Git commands that will come in handy in difficult situations. If you are familiar with other versioning tools this module will help you migrate to Git without much effort. Finally it ends with few best practices and hints that would develop good habits that every developer should posses.
Module 2, Git Version Control Cookbook, is designed to give you practical recipes for everyday Git usage. The recipes can be used directly or as an inspiration for you. This module will cover the Git data model through practical recipes and in-depth explanations so you get a deeper understanding of the internal workings of Git. The recipes also give you precise step-by-step instructions to various common and uncommon Git operations. The book can help ease your daily work with Git by providing recipes for common issues, useful tips and tricks, and in-depth clarifications of why and how they work.
Module 3, Mastering Git, starts with a quick implementation example of using Git for the collaborative development of a sample project to establish the foundation knowledge of Git's operational tasks and concepts. Furthermore, as you progress through this module, subsequent chapters provide detailed descriptions of the various areas of usage: from the source code archaeology, through managing your own work, to working with other developers. It also covers the advanced branching, merging and collaboration techniques. You will also learn to customize and extend Git, manage subprojects, and take up the administrative side of Git. Version control topics are accompanied by in-detail description of relevant parts of Git architecture and behavior. Finally the module ends with the Git best practicesm which will make you proficient in using Git.
-
No Comment