This article explains the concepts of Git’s working area, staging area, local and remote repositories, and details the operational differences between git fetch and git pull, including how each updates commit IDs and merges changes.
This guide walks through preparing the Linux environment on Kubernetes master and node machines, creating a bare Git repository, configuring SSH access, cloning the repository, and demonstrating core Git commands such as add, commit, status, diff, and push to a remote server.
This article provides a comprehensive visual guide to Git's most common commands, explaining how files move between the working directory, index, and repository, and detailing advanced operations like diff, commit, checkout, reset, merge, cherry‑pick, and rebase for effective version control.
The article examines common problematic comment styles—such as embedding contact info, design details, "how" instead of "why", usage instructions, and algorithm explanations—and suggests modern Git‑based practices to keep code clean and maintainable.
This article explains why clear, standardized commit messages are essential for efficient code review, outlines the recommended three‑part structure (subject, body, footer), defines type and scope conventions, and provides practical examples and scripts for generating changelogs and handling revert commits.
This extensive guide walks readers through Git fundamentals, covering Windows installation, core commands for repository creation, staging, committing, diffing, logging, resetting, branching, merging, remote synchronization, conflict resolution, stash usage, and best practices for collaborative development.
This guide explains how to structure Git branches—including master, develop, feature, release, and hotfix—provides command sequences for common tasks, and details a comprehensive commit‑message format based on the Angular convention to improve code review, release notes, and long‑term maintainability.
This article describes how Ctrip's flight front‑end team adopted GitLab Flow and the Light Merge branch strategy—detailing the evolution from single‑branch to multi‑branch approaches, the mechanics and advantages of Light Merge, and the automation of CI/CD, code review, and branch lifecycle management to achieve fast, reliable releases.
This article recounts Linus Torvalds' journey from studying operating systems with Minix to creating the Linux kernel, explains the microkernel versus monolithic debate, and highlights the technical, community, and ecosystem factors that propelled Linux to become the dominant open‑source operating system.
This article chronicles Linus Torvalds' journey from a graduate student tinkering with a 386 PC and Minix to creating the Linux kernel, highlighting the technical, historical, and community factors that propelled Linux to become the leading open‑source operating system.
This article introduces a reusable Java WebSocket client wrapper that adds convenient date handling, message logging, configurable constants, and performance‑testing utilities, explains its implementation details with full source code, and provides a simple demo showing connection, messaging, and graceful shutdown.
This article walks you through setting up Jenkins to clone a Spring Boot project from Gitee, configure JDK, Git, and Maven tools, create a freestyle job with parameterized builds, write shell scripts for stopping and starting the application, and troubleshoot common issues for a fully automated CI/CD pipeline.
This guide walks through installing and configuring Git, explains the working directory, staging area, and repository concepts, demonstrates common commands for initializing, committing, branching, tagging, reverting changes, and shows how to archive code and upgrade Git on CentOS.
This guide shows developers how to correct erroneous Git commits by using amend for message or author changes, reset (soft, mixed, hard, keep) to undo commits, and revert to create a new corrective commit, with practical code examples for each scenario.
This tutorial walks you through preparing the environment, installing Jenkins via Docker, configuring initial settings, integrating JDK, Maven, and Git, adding SSH servers and credentials, creating Maven jobs, and automating builds for Spring Boot applications on both GitHub and GitLab, including multi‑module project handling.
This article provides a comprehensive cheat sheet of the most frequently used Git commands, covering repository initialization, configuration, file staging, committing, branching, tagging, viewing history, remote synchronization, undoing changes, and miscellaneous tips, helping developers work efficiently with version control.
This guide presents a comprehensive, organized list of the most commonly used Git commands—including repository initialization, configuration, file staging, committing, branching, tagging, inspection, remote synchronization, and undo operations—complete with concise examples to help developers work efficiently with version control.
When refactor and business changes share a branch, you can safely remove unwanted refactor commits by interactively rebasing onto the last good commit and force‑pushing, ensuring later business commits remain intact.
This comprehensive guide walks you through Git fundamentals, explains the four work areas and file states, demonstrates essential commands for daily development, and dives into advanced topics such as branch management, conflict resolution, undo/revert strategies, tagging, and other powerful Git utilities.
This article compares Git merge and Git rebase, outlining their respective advantages, disadvantages, and practical guidelines for choosing the appropriate strategy based on team collaboration, workflow preferences, and conflict handling.
The article explains the importance of establishing Git commit message and branch naming standards, demonstrates the benefits of structured conventions, provides concrete examples and regex patterns, and shows how to enforce them with Git hooks such as Bitbucket's Yet Another Commit Checker.
This guide explains how to boost Git repository download speeds in China by mirroring projects to Gitee, using fork and clone operations, and optimizing submodule handling to achieve transfer rates of 1–2 MB/s instead of the typical 20 KB/s.
The article shares practical guidelines for open‑source contributors, from using a concise GitHub address and submitting small pull requests to adopting polite communication, clear commit messages, a complete profile with an avatar, prompt issue responses, well‑structured bug reports, and a high‑quality README, all backed by research on review effectiveness.
The article lists essential tools for Java developers in 2020, covering IDEs, version control, CI, testing, build automation, containerization, and operating system basics, and explains why each tool is valuable for both core and web Java programmers.
This article reviews common industry Git workflows such as Git Flow, GitHub Flow, GitLab Flow, Trunk‑based Flow and Aone Flow, analyzes Bytedance's multi‑environment deployment architecture, and presents concrete single‑, double‑ and triple‑branch practices together with recommendations for effective R&D process management.
This article explores the original 1,000‑line Git source from its first commit, showing how to obtain, compile, and analyze the core commands and objects—init‑db, update‑cache, cat‑file, show‑diff, write‑tree, read‑tree, commit‑tree—while explaining Git’s design principles, storage layout, SHA‑1 naming, and the limitations of the initial implementation.
GitHub announced that starting October 1 new repositories will default to the "main" branch instead of "master", a change driven by social concerns and industry-wide efforts to replace terminology perceived as discriminatory, with many other tech companies following suit.
This comprehensive guide walks you through the fundamentals of Git—including its role as a distributed version‑control system, the four work areas, common workflows, essential commands for cloning, committing, branching, merging, handling conflicts, undoing changes, tagging, and several advanced utilities—complete with code snippets and visual diagrams.
Discover ten practical VS Code techniques—from fast refactoring and custom view layouts to debugging, symbol navigation, split editing, terminal renaming, Git shortcuts, search snapshots, and visual page building—that can dramatically improve your frontend development efficiency and productivity.
This article explains how to use Git and Huawei Cloud DevCloud to implement development, test, and production branch strategies, manage permissions with protected branches, handle merge conflicts, and leverage merge requests and code reviews to improve DevOps efficiency.
This interactive Git tutorial teaches you how Git works under the hood—covering repositories, cloning, adding, committing, pushing, branching, merging, rebasing, cherry‑picking, resolving conflicts, rewriting history, and using reflog—so you can understand the concepts instead of just memorising commands.
The team introduced an Angular‑style Git commit‑message standard—type(scope): subject in Chinese—and built a webhook‑based monitoring service that validates pushes, alerts violations, tracks diff size and deletions, stores metrics, and visualizes compliance, improving traceability, readability, and automated changelog generation.
This article explains how to apply incremental thinking to ESLint code checks and webpack builds by using Git diff to detect changed files, running targeted linting and bundling, and demonstrates significant time savings in large front‑end projects.
This article introduces Sharness, a lightweight shell‑script testing framework derived from Git's own test suite, explains its structure, test case format, built‑in functions, debugging tricks, extensions, and provides practical code examples for writing robust TAP‑compatible tests.
This article explains why clear, standardized Git commit messages are essential, outlines a practical commit format with required types, optional scopes, and concise subjects, and describes a webhook‑based monitoring service that enforces the rules, improves traceability, and enables automated changelog generation.
This article outlines best practices for Git branch management—including naming conventions for master, develop, feature, release, and hotfix branches—and provides detailed commit message guidelines based on the Angular style, complete with example commands and formatting rules to improve workflow and code traceability.
This article provides a thorough overview of Git, covering its origins, core workflow areas, file‑status transitions, essential and advanced commands, merge and rebase strategies, object model, and reference handling, all illustrated with practical code snippets and visual diagrams.
This guide explains how Chinese developers can overcome slow GitHub clone speeds by mirroring repositories to Gitee, achieving download rates of 1–2 MB/s and also provides a method to accelerate submodule fetching.
This article explains the conventional Git commit message format, its components and benefits, and demonstrates how to enforce the standard using tools such as Commitizen, commitlint, husky, and standard-version, providing practical examples and configuration snippets for developers.
This article explains the purpose of Git branching, compares four mainstream branch models—TBD, Git‑Flow, GitHub‑Flow, and GitLab‑Flow—highlights their characteristics, pros and cons, and provides practical guidance on selecting the most suitable strategy based on team size, release cadence, and product complexity.
This comprehensive guide covers Git fundamentals, including workspace concepts, configuration, common commands, branch management, merging strategies, hooks, and troubleshooting tips, providing developers with a complete reference to efficiently use Git for version control in any project.
This guide explains what Vim color schemes are, shows how to view and switch built‑in schemes, demonstrates installing external themes from GitHub, and details how to make a chosen theme permanent, complete with example commands and recommended theme previews.
This article explains Git's origin, its snapshot‑based data model, the differences between centralized and distributed version control, and provides a concise guide to the 12 most frequently used Git commands for local operations, remote interaction, and branch management.
This guide explains Git’s origin, its snapshot‑based data model, and walks through twelve essential commands covering local operations, remote interactions, and branch management, while also providing visual diagrams and recommended learning resources for mastering version control.
The article examines the recent push to rename Git's default "master" branch to "main", exploring the motivations behind the change, community reactions, potential impacts on existing projects, and the broader discussion about terminology in software development.
This article explains what Git is, why version control is essential, compares local, centralized, and distributed systems, describes Git's storage mechanisms and object types, and outlines the typical Git workflow with practical examples.
This comprehensive guide explains what Git is, compares it with SVN, shows how to install Git on Windows, and walks through creating repositories, adding and committing files, checking status, viewing diffs and logs, resetting versions, managing branches, handling remote repositories, using stash, and collaborating with teammates using push and pull commands.
This article compiles essential DevOps interview questions covering version control differences between Git and SVN, MySQL master‑slave replication mechanics, Kafka versus traditional MQ, Kubernetes service types, pod communication, health checks, resource limits, link types, and permanent mounting techniques.
This article systematically explores Git’s underlying architecture, detailing the lifecycle of objects, core data structures, packfile formats, indexing mechanisms, and the algorithms used for object retrieval, while providing practical command examples and visual diagrams to demystify Git’s storage and retrieval models.
This guide shows how to locate every .git directory within a few levels, trim the paths, and run git pull on each repository using a single pipeline command that can also be saved as a convenient shell alias.
This guide walks through Git's fundamental setup—including configuring username and email, initializing a repository, performing file additions, deletions, commits, managing branches, connecting to remote repositories, and resolving merge conflicts, providing command-line examples for each step.
This guide explains how to overcome the typical 20 kB/s GitHub download limit in China by mirroring repositories to Gitee, providing step‑by‑step instructions to achieve 1‑2 MB/s clone speeds for both main projects and their submodules.
In this interview, Git’s long‑time maintainer Junio Hamano reflects on the project’s 15‑year history, its community, design philosophy, favorite features, and the changes he would still make to improve version control for developers worldwide.
This article provides a visual, step‑by‑step guide to essential Git commands—including merge (fast‑forward and no‑ff), rebase (including interactive mode), reset (soft and hard), revert, cherry‑pick, fetch, pull, and reflog—explaining their behavior, use cases, and common pitfalls with animated illustrations.
This article explains how using Git's cherry‑pick to copy commits between branches can lead to merge conflicts or silently incorrect code states, illustrates three possible outcomes with a concrete example, and advises when cherry‑pick is appropriate versus using a full merge.
This tutorial walks through creating an empty GitHub repository, importing it, adding a content service and additional microservices, configuring the Maven parent pom, setting up a root Maven configuration and .gitignore, and finally committing the code for the PassJava Java microservice suite.
This guide walks you through configuring Git with a username and email, generating and adding an SSH key to GitHub, and troubleshooting common errors such as the Fatal HttpRequestException by installing the Git Credential Manager for Windows.
This guide explains why Gogs is a lightweight alternative to GitLab, outlines its key features, details the required environment, and provides step‑by‑step Linux commands for installing, configuring, and running the self‑hosted Git server, including troubleshooting tips and post‑installation notes.
This guide compiles the most frequently used Git commands, explaining their purpose, common options, and practical scenarios such as logging, branching, committing, rebasing, merging, stashing, and reverting, to help developers work efficiently with version control in real-world projects.
This article introduces essential and less‑common Git commands, explains basic operations like clone, pull, branch, and commit, then dives into advanced topics such as merge versus rebase, cherry‑pick, reset versus revert, and HEAD reference syntax, providing clear examples and visual illustrations.
This article explains how Git stores repository data by exploring the .git folder structure, the composition of a commit, object storage, and the role of branches, tags, and HEAD, providing concrete examples and command snippets to demystify Git’s inner workings.
This guide walks you through the most useful Git commands—from cloning a repository and basic workflow operations to advanced techniques like rebasing, cherry‑picking, and resetting—explaining when and how to use each command, illustrating differences with visual diagrams, and warning about pitfalls when rewriting history.
GitHub CLI (gh) is a cross‑platform command‑line tool that lets developers clone repositories, filter issues, manage pull requests, create branches, and monitor PR status directly from the terminal, streamlining open‑source contributions on macOS, Windows, and Linux.
This guide provides a concise cheat sheet of advanced Git commands—including navigation, history inspection, resetting, rebasing, squashing, stashing, cleaning, and custom aliases—to help developers work more efficiently with version control.
This cheat sheet gathers essential advanced Git commands—navigation, history inspection, commit amendment, interactive rebasing, stash management, branch cleanup, and useful aliases—providing concise examples and explanations to help developers work more efficiently with version control.
This article compares Git and SVN, explains the core concepts of Git such as workspace, index, and repository, and provides a comprehensive set of frequently used Git commands—including initialization, configuration, branching, committing, pulling, and Git‑SVN operations—complete with code snippets and illustrative images.
This comprehensive guide walks you through Git fundamentals, differences from SVN, Windows installation, core commands, remote repository setup, branch management, conflict resolution, stash usage, and multi‑person collaboration, all illustrated with step‑by‑step screenshots and code snippets.
This article compiles more than seventy practical Git commands and techniques, explains core concepts such as working directory, staging area, and commit IDs, and provides ready‑to‑use snippets for everyday version‑control tasks, all backed by the open‑source git‑tips and HelloGitHub projects.
This article introduces Git as a distributed version control system, explains its core workflow and branch model, and provides step‑by‑step instructions for configuring, cloning, checking out, committing, pushing, and using Git commands within IntelliJ IDEA, including useful screenshots.
This article analyzes common source‑code management patterns for numerous small projects, identifies their drawbacks, and proposes a hybrid solution that combines a single‑git repository with git‑submodule based sub‑projects, automated shell scripts, and Umi‑based tooling to achieve unified yet isolated development and deployment.
Git 2.23 splits the overloaded git checkout command into two focused commands—git switch for branch operations and git restore for file recovery—making version‑control workflows clearer and reducing confusion for new users.
This guide explains Git's core workflow—adding, committing, and pushing—covers the four Git areas (working, staging, local, remote), describes the five file states, shows how to inspect changes with diff commands, and provides step‑by‑step commands to revert modifications at any stage.
This guide explains Git's core workflow—adding, committing, and pushing—breaks down the four Git areas and five file states, shows how to inspect changes with various git diff commands, and provides step‑by‑step commands to undo modifications at each stage, all illustrated with practical examples.
This guide explains why version control matters, introduces Git as the leading distributed system, and provides a concise cheat‑sheet of the most important commands—from initializing a repository to branching, merging, and undoing changes—so you can work efficiently and collaborate without losing any history.
This guide explains five common Git workflows—from the simple master‑only model to feature, developer, combined, and release branching strategies—detailing their purposes, advantages, and when to adopt each to keep codebases organized and avoid conflicts in projects of any size.
This article walks through four practical Git techniques—revert, reset, rebase + revert, and a file‑copy method—to safely roll back code when faced with performance‑critical bugs and complex version histories, while preserving commit history for future debugging.
This cheat sheet compiles essential advanced Git commands—branch navigation, log inspection, reset recovery, diff comparison, commit customization, squash/fixup, rebase with exec, stash management, repository cleanup, and handy aliases—to help developers work more efficiently and avoid common pitfalls.
This article walks through four practical Git techniques—revert, reset, rebase + revert, and a file‑copy method—to safely roll back code when a problematic jar package causes performance issues, comparing their trade‑offs and providing step‑by‑step command examples.
This article explains Git's evolution from a distributed version control system to the industry standard, outlines its key advantages and drawbacks, and provides a comprehensive list of essential commands for branching, stashing, resetting, tagging, and repository management.
Git 2.25.0 introduces experimental partial clone and sparse checkout features that let developers fetch only needed objects and skip unnecessary files during checkout, dramatically reducing network and storage costs for massive repositories while simplifying configuration through the new git sparse-checkout command.
This guide compares Git and SVN, explains Git's core workflow, provides essential commands for everyday use, and shows how to bridge SVN repositories with Git‑SVN, offering a complete reference for developers transitioning between the two version‑control systems.
This guide explains a straightforward Git workflow for multi‑developer teams, covering master, release, and feature branches, pull‑request reviews, handling merge conflicts, and merging back to master, illustrated with clear examples and images.
This article explains how to construct a basic Tekton CI/CD pipeline on Kubernetes, covering core concepts, required resources, task definitions, pipeline templates, secret and ServiceAccount setup, execution monitoring, and includes full YAML and shell code examples for building, testing, and deploying a container image.
This guide introduces the open‑source GitStats tool, explains how to install its Python and Gnuplot dependencies on Linux, demonstrates step‑by‑step commands to generate a comprehensive HTML report for a Git repository, and interprets the resulting statistics on commits, contributors, file types, and tags.
This article walks through Git's internal storage model using a concrete example, showing how blobs, trees, commits and tags are created, how the three Git areas (working directory, index, repository) interact, and why Git can efficiently track history while ensuring data integrity.
Linus Torvalds shares his dual impact on technology through Linux and Git, explains his pragmatic engineering mindset, the philosophy of open source collaboration, and demonstrates the difference between messy and elegant C code using real‑world examples.
Learn how to configure Git to push your code simultaneously to multiple remote repositories by adding multiple URLs in the .git/config file, using remote add commands, and executing a single git push command, with step-by-step examples and cautions about force pushes.
This comprehensive guide walks you through Git's core concepts and commands—including repository initialization, adding and committing files, pulling, pushing, branching, merging, rebasing, and useful tips—so you can confidently manage version control in any project.
This tutorial walks through a practical Git scenario, comparing step‑by‑step merge and rebase workflows, illustrating each command with screenshots, and explaining when to choose each method to keep your repository history clean and conflict‑free.
This guide walks you through creating feature branches, inspecting remote repositories, pushing and fetching branches, handling merge conflicts, and coordinating multi‑person workflows with Git, providing concrete commands and visual examples for each step.
This guide walks through disabling fast‑forward merges with --no-ff, demonstrates the full commit workflow, shows how to push changes to a remote repository, resolves common push errors, and outlines a practical branch management strategy for stable master and development branches.
This guide walks through essential Git habits, explains how to inspect changes, and provides step‑by‑step commands for resetting local or remote commits, handling renamed files, and understanding core concepts like the working directory, repository, staging area, and HEAD pointer.
At the European Open‑Source Summit, Linus Torvalds explained that he now spends his days reviewing and replying to email patches, acting as a code maintainer rather than a developer, while reflecting on Git’s impact, his evolving role, and lingering imposter syndrome.
This article provides a concise reference of essential Git commands covering branch management, stashing changes, resetting revisions, tagging commits, and various routine operations such as pushing, ignoring files, and configuring password‑less authentication.
This guide compiles ten practical Git and GitHub shortcuts, commands, and tricks—including keyboard shortcuts, URL modifiers, diff formats, and useful CLI commands—to help developers work faster and manage repositories more efficiently.
This guide explains core Git concepts such as local and remote branches, commit IDs, creating and amending branches, when to use rebase versus merge, interactive rebasing to squash commits, cherry‑picking, file checkout, pruning unused objects, and stash management, providing practical command examples for everyday development.
This article explains how to effectively apply Git in a team setting, covering commit habits, branch management with Git Flow, tool configuration, merge strategies, and release processes, offering practical examples and visual guides to improve collaboration and maintain a clean development history.
This comprehensive guide explains what Doom Emacs is, its speed‑focused features, step‑by‑step installation across platforms, core concepts like keybindings, buffers, windows and modules, plus practical commands and a custom module example, helping users become efficient Emacs power users.
This guide walks you through setting up a remote Git repository, configuring IntelliJ IDEA’s Git integration, cloning a project, initializing and committing code, pushing changes, pulling updates, managing branches, handling merge conflicts, and reviewing commit history, all illustrated with clear screenshots.
This guide compiles the most useful Git commands for managing branches, stashing changes, reverting commits, handling tags, performing common repository tasks, and configuring credential storage, providing concise explanations and practical examples for each operation.
