This article provides a comprehensive visual guide to the most frequently used Git commands, explaining their purpose, usage, and effects on the working directory, index, and repository, while illustrating concepts such as commits, branches, merges, rebases, and detached HEAD with clear diagrams.
This article provides a comprehensive guide to Git, covering its purpose, installation on Windows, Linux, and macOS, account registration, SSH key setup, creating repositories, cloning, branch management, merging, conflict resolution, and version rollback procedures.
This article provides a comprehensive, illustrated walkthrough of Git’s core commands—add, commit, reset, checkout, merge, rebase, and more—explaining how they move files between the working directory, index, and repository, and clarifying concepts such as HEAD, branches, and detached HEAD states.
The Linux 5.8 kernel, despite its record‑breaking size, remains maintainable thanks to a disciplined Git‑based workflow that follows seven fundamental principles, continuous testing, and a culture of trust that together set a gold standard for large‑scale open‑source development.
This article delves into Git’s core architecture, explaining its fast, distributed nature, immutable objects, porcelain and plumbing commands, the content‑addressable version database, and how init, add, and commit manipulate the working directory, index, and repository to create snapshots of project history.
This article outlines five practical version‑control best practices—choosing a suitable branching strategy, committing small frequent changes, writing descriptive commit messages, developing on branches, and performing regular code reviews—to improve team collaboration and delivery speed in modern software projects.
This guide presents a comprehensive collection of frequently used Git commands—including common operations, alias setup, repository creation, committing, history viewing, undoing changes, branch and tag management, merging, rebasing, remote handling, archiving, and configuration—organized for quick reference by developers.
This guide offers test developers actionable habits—from writing pseudo‑code and breaking tasks into manageable items to mastering version control, refactoring, commenting, solution hunting, embracing change, and automating repetitive work—to become more efficient and maintainable engineers.
A senior architect learns why he remains stuck while his former colleague climbs the ladder, discovering eight actionable habits—from reading all code and judging project direction to mastering meetings, version control, and pragmatic coding—that can transform technical expertise into real career advancement.
This guide shows how to create matching repositories on GitHub and Gitee, configure a single local Git repository to push to both remotes, and keep them synchronized automatically, providing step‑by‑step commands, config file edits, and practical tips for developers.
This guide walks developers through the most useful Git commands for inspecting changes, safely reverting commits, cleaning untracked files, customizing the default editor, and creating handy Bash aliases, providing clear examples, code snippets, and practical tips to streamline version‑control workflows.
This article recounts a twelve‑year‑long French government software project that amassed over six million lines of C++ code, suffered from outdated technology, chaotic version control, absurd management policies, and ultimately collapsed, offering stark lessons for developers and project leaders.
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.
This tutorial walks you through using Flyway in a Spring Boot application to manage MySQL schema versions, from initial table creation and CRUD implementation to incremental migrations like adding new columns, complete with Maven dependencies, SQL scripts, Java code, and automated tests.
DVC is an open‑source data version control system that extends Git to manage large machine‑learning models, datasets, and pipelines, enabling reproducible experiments, low‑friction branching, metric tracking, and seamless collaboration across various storage backends.
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 explains how Git stores data by describing the .git directory layout, the four object types (blob, tree, commit, tag), how objects are hashed and organized, and how Git packs objects to save space, answering why a second commit stores a full file.
This guide walks through installing Subversion on a Docker host, configuring repository access and authentication, testing basic SVN operations, and integrating the SVN server with Jenkins to automate file distribution and builds, providing step‑by‑step commands and screenshots.
This article explains how to define Elasticsearch mappings, use automatic and manual mapping, work with basic data types, multi‑fields and predefined fields, and perform document updates, version‑based concurrency control, and deletions, providing practical curl examples for each operation.
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 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.
This article introduces ten essential Git commands—including diff, log, reset, revert, clean, and commit‑amend—explains how to escape Vim, change the default editor, and create Bash aliases for faster Git operations, providing practical examples and code snippets for developers.
This article reports on Tencent’s Gongfeng version‑control system receiving top‑level DevOps standard assessment at the 14th GOPS Global Operations Conference, includes an interview with the system’s director about its design, deployment challenges, future plans, and the broader Chinese DevOps standards initiative.
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.
An in‑depth exploration of Git’s initial 1,000‑line source code reveals the foundational design principles—workspace, index, objects, and three core object types—showing how early implementations of init‑db, update‑cache, write‑tree, and commit‑tree established the powerful, distributed version‑control system we use today.
The article explains a range of source‑code branching patterns—including source branches, mainlines, feature branches, release branches, maturity branches, hot‑fix branches, release trains and team integration branches—detailing their purposes, trade‑offs, integration frequencies, and how teams can choose the most suitable strategy for effective software development.
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.
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.
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.
Infrastructure as Code (IaC) streamlines DevOps by automating provisioning, ensuring reproducible and consistent environments, enabling version‑controlled configurations, and supporting fast feedback through testing, while the article outlines its core benefits, key principles, goals, and provides practical Ansible and Testinfra examples.
The article presents practical tips for test developers, covering pseudocode, task breakdown, version control, refactoring, commenting, solution hunting, embracing change, handling inevitable bugs, and automating repetitive work to improve productivity and code quality.
This article compares major Git branching strategies—including Trunk‑Based Development, Git‑Flow, GitHub‑Flow, and GitLab‑Flow—detailing their workflows, advantages, drawbacks, and suitability for different team sizes and release cycles, and offers guidance on selecting the optimal model for your project.
This comprehensive guide covers Git fundamentals, including workspace concepts, configuration, common commands for adding, committing, branching, merging, rebasing, stashing, submodules, hook setup, branch management strategies, and solutions to frequent Git issues, providing developers with a complete reference for effective version control.
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 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.
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 article describes how the Beetle platform, together with the LuBan system, automates multi‑branch creation, testing, gray release, and hot‑fix processes for app development, addressing challenges of branch‑demand association, merge coordination, and version synchronization to improve delivery speed and quality.
An ex‑consultant recounts a twelve‑year French government software project that spiraled into a disastrous 600‑plus‑million‑line C++ codebase, plagued by outdated technology, chaotic version control, absurd management practices, and massive inefficiencies, ultimately ending in prison for its leaders.
This comprehensive tutorial walks you through installing PyCharm, creating and running Python projects, debugging, testing, navigating large codebases, integrating version control, using plugins and external tools, and exploring professional features like Django support, all illustrated with step‑by‑step screenshots and shortcuts.
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.
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 xManager implements comprehensive instance configuration management for big‑data services, covering configuration groups, versioning, node‑level differentiation, database schema, installation workflow, group creation, configuration changes, version switching, and deployment scripts.
This comprehensive guide demystifies Git by explaining version‑control concepts, commit objects, repository initialization, staging, branching, tagging, merging, conflict handling, and push strategies, empowering developers to use Git confidently and efficiently.
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 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.
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 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.
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 article introduces Flyway as a database migration tool, explains its working principle, directory and naming conventions, supported databases, and provides detailed step‑by‑step instructions, best‑practice guidelines, and troubleshooting tips for safely managing MySQL schema changes in production environments.
This article analyzes the challenges of managing the entire machine‑learning lifecycle, reviews existing traceability approaches, and proposes comprehensive methods for versioned management of model training, prediction, and online service to improve efficiency, reproducibility, and maintenance of AI systems.
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 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.
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 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.
This article outlines the essential basic and advanced tools—including IDEs, version control, CI servers, testing frameworks, build systems, containerization, and Linux—that Java developers should master in 2019 to improve productivity and code quality.
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 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 recounts a twelve‑year‑old French government software project that ballooned to over six million lines of C++ code, suffered from obsolete technology, chaotic version control, and absurd management practices, ultimately ending in failure and the arrest of its leaders.
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 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.
This guide compiles the most commonly used Git commands for branch management, stashing changes, reverting commits, handling tags, performing routine operations, initializing repositories, ignoring files, and configuring password‑less pushes, providing a concise reference for developers to streamline version control workflows.
This article explains a comprehensive Git branching strategy for large projects, detailing the roles and workflows of master, develop, hotfix, and release branches, and how they support product development, testing, and release management.
This article provides a detailed, beginner‑friendly tutorial on Git, covering its purpose, installation on Windows and macOS, repository structure, essential commands for committing, branching, merging, rebasing, stashing, tagging, and collaborative workflows, all illustrated with clear examples and code snippets.
This article explains the fundamental differences between SVN and Git, outlines the git‑svn bridge commands, and describes a self‑service migration architecture that enables large‑scale, stable migration of thousands of projects across multiple business units.
This article compares classic Git Flow with trunk‑based development and introduces a hybrid Omega branching model, explaining each branch type, their pros and cons, and how the new approach balances rapid iteration with release stability.
While Git dominates version control with its distributed model and flexible branching, many developers still stumble over common pitfalls; this article collects real‑world problems—from recovering lost commits with reflog to fixing commit messages, undoing accidental master pushes, and understanding diff behavior—offering practical commands to resolve them.
This article provides a detailed overview of Git as a distributed version control system, covering installation on Windows, global user configuration, core concepts such as working directory, repository, staging area and HEAD, typical branching workflows, remote repository setup, and a collection of frequently used Git commands.
This article traces GitHub’s evolution from a weekend project in 2008 to a $75 billion Microsoft acquisition, examining its innovative free‑plus‑paid model, community‑driven growth, strategic product decisions, and the lessons it offers for product and R&D management.
In this presentation, a veteran participant of the Tencent Advertising Algorithm Competition shares practical advice on building simple, efficient models, optimizing code performance, managing version control with Git, and maintaining clean coding practices to improve competition outcomes and foster better engineering habits.
This comprehensive guide walks readers through Git fundamentals, including repository initialization, staging, committing, branch and tag management, rebasing, merging, conflict resolution, and push strategies, supplemented by practical command examples and visual diagrams to demystify version control.
The article explains the concepts, advantages, and drawbacks of optimistic and pessimistic locking, provides real‑world examples such as lost updates and inconsistent reads, and offers practical guidelines and implementation techniques for selecting the appropriate concurrency control strategy in database‑driven applications.
Learn the most useful Git commands for inspecting changes, undoing commits, cleaning untracked files, organizing history, configuring editors, and creating shortcuts, with clear examples, parameter explanations, and Bash alias setups to boost productivity for developers, data scientists, and product managers.
