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.
This comprehensive guide walks you through Git fundamentals, installation on Windows, core concepts like workspace, index, repository and remote, essential commands for creating repositories, committing, branching, merging, stashing, handling conflicts, and collaborating with multiple developers using GitHub.
The article explains the concepts, advantages, disadvantages, and practical selection criteria of optimistic and pessimistic locking in concurrent systems, illustrating the ideas with version‑control examples and offering implementation tips for both database and web applications.
This article explains the differences between git reset and git revert, shows how each command moves the HEAD pointer, demonstrates step‑by‑step examples for undoing erroneous commits, and advises when to prefer revert to preserve history and avoid forced pushes.
This guide outlines the ten core competencies—from data structures and version control to IDEs, databases, Unix, Excel, programming languages, networking, and scripting—that every new or aspiring software developer should master to build a successful career.
The article explores how to deepen functional testing through horizontal expansion by focusing on product knowledge, development quality control, and environment configuration, offering practical guidance on version control, test case integration, database and configuration management, and the critical role of logs.
This article explains how PouchContainer, Alibaba’s open‑source container runtime, aligns its internal and external codebases through detailed difference analysis, a plugin architecture, rigorous testing, and a disciplined Git workflow to ensure stable, extensible, and synchronized releases.
This article expands on functional testing by exploring three key control areas—product knowledge, development quality through version control and test case integration, and environment configuration—offering practical insights and best practices for testers to enhance test effectiveness and drive project quality.
The article outlines the three core principles of software configuration management—versioning everything, sharing a single source of truth, and standardizing with automation—explaining how they underpin continuous delivery pipelines and offering practical validation questions for teams.
This guide walks you through essential Git operations—including cloning repositories, managing branches, viewing logs, rolling back versions, handling file changes, and configuring user settings—so you can confidently control source code throughout the development lifecycle.
Learn how to set up and use Git‑Flow for efficient project development, covering installation, branch strategies, feature, release, and hotfix workflows with practical command examples and visual diagrams to help teams maintain clean, organized repositories.
This article explains why excessive commits harm code review and branch hygiene, then demonstrates how to use Git rebase to squash commits, synchronize branches, resolve conflicts, and safely rewrite history with practical command examples and visual illustrations.
This article provides a comprehensive overview of essential Git commands, covering repository initialization, staging, committing, branching, merging, remote synchronization, tag management, and configuration, enabling readers to effectively manage version control workflows in software projects.
This guide explains how to set up an efficient Git workflow for multi‑developer projects, covering the purpose of master, release, and feature branches, the pull‑request process, handling merge conflicts, and finally merging release changes back into master.
Learn essential yet less‑frequent Git commands—including how to amend commits, combine multiple commits, swiftly resolve merge conflicts using ‘theirs’ or ‘ours’, and batch‑delete tags—complete with practical examples to streamline version control for projects of any size.
This guide explains how to use the Linux diff command for file comparison, covering its basic syntax, common options like -b, -B, -i, -r, and demonstrating normal, context, unified, and side‑by‑side output formats with concrete examples and interpretation of the results.
This article details Beijing Bank's 2017‑2018 journey of adopting Azure DevOps Server to enable a regulated yet agile development process, covering challenges, project‑, version‑, and test‑management solutions, gene‑adaptation of TFS, and the resulting dual‑mode, automated workflow for a large financial institution.
This comprehensive guide walks you through installing Git on Windows, explains core concepts such as workspace, index, repository and remote, demonstrates common commands for creating, committing, branching, merging, stashing, and collaborating with GitHub, and shows how to resolve conflicts and revert changes.
This article introduces a shell script that automates the typical Git workflow of cloning a repository, creating a new development branch from master, pushing the branch to the remote server, and establishing upstream tracking, allowing developers to focus solely on code changes.
This article presents a comprehensive Git branching model designed for large-scale dual‑mode development, details naming conventions, granularity rules, code picking methods, shallow clone and sparse checkout techniques, and demonstrates its successful application in the Agricultural Bank's C3 credit management system while also announcing a related DevOps live event.
This article explains how development teams can use a single‑release Git workflow—creating release branches from master, managing feature branches, merging or rebasing, tagging, pull‑requests, and cleaning up branches—to streamline development and deployment.
This article explains how to reduce TFS database growth by managing document, source code, build package, and test artifact storage, offering best‑practice recommendations, configuration tips, and SQL scripts for analyzing and cleaning up large data tables and optimizing repository structures.
Learn how to use Git's cherry-pick command to selectively copy individual or ranges of commits from one branch to another, with step‑by‑step examples, command syntax, and tips for handling multiple commits and postponing automatic commits.
This article explains Git's three core areas—working directory, staging (index) area, and history—detailing how commands like git add, commit, reset, checkout, and revert manipulate these zones, with visual diagrams and practical examples for effective version control.
This article explains the importance of version control systems for collaborative software development, outlines the differences between distributed and centralized VCS, offers best‑practice guidelines, and compares popular open‑source tools like Git, Mercurial, and SVN.
This comprehensive guide walks you through installing Git, configuring user information, initializing repositories, tracking and committing changes, managing branches, handling remotes, using tags, rebasing, and creating command aliases, all illustrated with clear examples and screenshots.
This guide walks through Git's core commands—including add, commit, reset, checkout, diff, merge, cherry‑pick, and rebase—explaining how they move files among the working directory, index, and repository, how branches and HEAD behave, and what happens under the hood in the object database.
This article explains Git’s four areas (working, staging, local repository, remote repository) and five file states (origin, modified/untracked, staged, committed, pushed), detailing step‑by‑step commands such as git add, commit, push, and how to revert changes using git reset, checkout, and clean.
The article explains Git’s fundamental architecture, describing how trees, blobs, and commits are stored as objects identified by hashes, how version history forms a linked list, and how optimizations such as directory sharding and garbage collection fit into this design.
This article explores why GitHub, the world’s largest open‑source code host with 85 million repositories and 28 million developers, remains indispensable by examining its strong community, massive code library, simple version control, extensive integrations, and secure cloud storage.
An in‑depth interview with Jun‑ichiro Hamano reveals how he joined the Git project, the challenges of early merge implementations, the relationship between Git and GitHub, and the personal qualities Linus Torvalds values in top programmers.
The Spring Project team adopted Scrum and a physical Kanban board, combined with TFS work items, to streamline requirement tracking, code‑story linkage, version control, and automated deployment, resulting in clearer process management, higher delivery quality, and improved team efficiency across fifteen iterations.
Discover twelve practical Git tricks—from configuring global and repository settings to using aliases, visualizing commit graphs, safe force‑pushes, and powerful add/checkout options—that can dramatically improve your workflow and efficiency.
This article explains what a pull request is, why it is essential for code quality and collaboration, and walks through the typical four‑step workflow—creating a branch, opening a pull request, updating it, and completing the merge—using Git and TFS/VSTS examples.
This article explains the mechanics of Git pull (fetch + merge), outlines common merge‑conflict scenarios such as modifying different files, overlapping changes, and renaming files, and provides step‑by‑step solutions to resolve these conflicts in collaborative development.
This article explains how Git records history using a graph of commits, demonstrates creating feature and hotfix branches, shows fast‑forward and merge operations with command‑line examples, and clarifies how branch pointers move during typical enterprise development workflows.
This article introduces the basic Git workflow for enterprise developers, covering branch creation, committing changes, and pushing branches to a central repository, with step-by-step command examples and explanations of staging, status, and branch management.
This article provides a comprehensive overview of Git for enterprise developers, covering repository basics, the .git directory, configuration files like .gitattributes and .gitignore, the three‑level configuration system, and step‑by‑step instructions for creating and cloning repositories on Windows.
This guide introduces the g4e series, explains why version control is essential, walks through installing Git for Windows, configuring user identity and enterprise credentials, and reviews popular Git GUI tools, Visual Studio integration, VS Code extensions, VSTS/TFS private servers, and the Cmder command‑line alternative.
This article introduces the fundamental concepts of Git for enterprise developers, covering its distributed version control model, core operations such as commits, branches, and file states, and highlighting its advantages like parallel development, faster releases, strong community support, and integration with modern tooling.
This article introduces the fundamentals of using Git as a version‑control system for enterprise development, covering why VCS is needed, Git's advantages, installation, repository initialization, branching, history inspection, pull‑request workflow, and how Git supports unified workflows, collaboration, history preservation, and CI/CD integration.
When Git commands produce hard‑to‑diagnose errors, you can activate detailed tracing in PowerShell by setting the environment variables GIT_TRACE and GIT_CURL_VERBOSE to 1, which makes Git output extensive operation details to help locate the problem.
This guide presents a comprehensive, four‑section tutorial that equips enterprise developers with essential Git knowledge—from basic concepts and setup to advanced workflows, branch strategies, and integration with CI/CD—addressing common challenges and improving large‑scale development efficiency.
This tutorial shows how to integrate Flyway into a Spring Boot application for database version control, covering dependency setup, creation of versioned SQL scripts, configuration, execution of migrations during tests, and handling of checksum validation errors.
The article uses the iPhone and Android stories to illustrate how Git’s open, collaborative, and service‑oriented model outperforms traditional SVN, highlighting the strategic shift from closed systems to distributed development, knowledge sharing, and continuous integration.
This article traces the history of Linux's source‑code management, explains why Linus Torvalds created Git as a distributed version‑control system, compares it with centralized systems like CVS and SVN, and highlights Git’s key advantages and ecosystem.
Gitflow provides a disciplined branching model for teams, using dedicated master, develop, feature, release, and hotfix branches to manage development, releases, and maintenance, and this guide walks through its concepts, branch roles, and detailed command‑line steps with examples to implement the workflow effectively.
This guide provides a comprehensive collection of Git commands covering repository initialization, user configuration, status checks, staging, committing, branching, checkout, merging, remote operations, tag management, diffing, stash handling, and repository maintenance for effective version control.
This guide presents a thorough collection of Subversion (SVN) commands for Linux, covering checkout, add, commit, lock/unlock, update, status, delete, log, info, diff, merge, help, list, mkdir, revert, switch, resolve, cat, cleanup, import and related usage examples, helping users manage repositories efficiently.
The article outlines six major trends shaping modern programming—from industry standards and popular third‑party modules to modular programming, framework adoption, testing practices, cross‑platform development, and the rise of tooling, automation, and ecosystem awareness—highlighting why developers must stay current.
The article explains how treating CI/CD pipelines as code—managed via version control and domain‑specific languages—solves configuration drift, reproducibility, and documentation issues, and outlines practical steps and tool examples for implementing this DevOps practice.
This article introduces Git as a distributed version‑control system and GitHub as a hosting platform, explains why they are useful, and walks through core commands such as init, add, commit, branch, tag, and push to help developers manage code efficiently and collaborate effectively.
This article provides a step‑by‑step walkthrough of common Git operations—including repository initialization, staging, committing, viewing status, diffing, logging, reverting, remote configuration, branching, tagging, and .gitignore setup—illustrated with command examples and screenshots.
This article provides a detailed tutorial on installing Git on various platforms, configuring user information and aliases, managing .gitignore files, performing core repository actions such as init, add, commit, diff, and status, as well as advanced branch, tag, and remote repository operations using the command line.
This guide explains Git's origins, compares distributed and centralized version control, walks through creating a repository, adding and committing files, switching versions, and using reset, log, and reflog to recover previous states, providing practical command‑line examples for developers.
This article breaks down comprehensive configuration management—covering code and build artifact versioning, application settings, and environment provisioning—explaining why it is the cornerstone of continuous delivery and offering concrete branch strategies, Git practices, artifact handling, injection methods, and automation tools to achieve reliable, low‑risk software releases.
A comprehensive, English-language cheat sheet that explains Git terminology and provides ready-to-use command snippets for initializing repositories, configuring settings, managing files, committing changes, handling branches, tags, viewing history, synchronizing remotes, and undoing actions.
This article provides a comprehensive theoretical overview of Git, covering version‑control fundamentals, the architecture of blobs, trees and commits, SHA‑1 hashing, references, branching, merging, rebasing, and best‑practice workflows for effective distributed source‑code management.
This article provides a comprehensive theoretical overview of Git, covering version‑control system types, Git's snapshot model, object storage, references, branching, merging strategies, and rebasing, helping readers grasp how Git manages files and history.
Modular design simplifies Node.js development but introduces uncertainty about third‑party modules, so understanding which packages you rely on, their usage, popularity, version status, and last update dates can boost confidence and maintainability of your codebase.
The article explains the three main types of version control systems, contrasts centralized tools like SVN with distributed ones like Git, and illustrates through three developer scenarios how Git’s branching and conflict‑resolution features simplify collaboration, speed up workflows, and avoid common pitfalls.
This article provides a step‑by‑step beginner tutorial on GitHub, explaining what Git is, how to create repositories, clone them locally, make changes, commit and sync, roll back versions, and explore various non‑coding uses such as writing books, managing documents, and building personal sites.
Google’s engineers explain in an ACM Communications paper how their custom monolithic repository, managed by the Piper version‑control system built on Spanner, supports billions of files and lines of code, enabling trunk‑based development, rapid code visibility, and large‑scale refactoring, while also requiring substantial tooling investment and operational complexity.
This article explains the principles of version control systems, illustrating the evolution from manual file‑locking methods to modern distributed workflows with checkout, check‑in, merging, branching, and collaborative features exemplified by the custom Hit and HitHub platforms.
This article reviews several standalone Git GUI tools such as GitHub Desktop, SourceTree, and TortoiseGit, as well as IDE‑integrated Git support in Xcode, Eclipse, Visual Studio, and VS Code, highlighting their features, platform compatibility, and practical usage tips for developers.
This guide walks you through ten powerful Git techniques—including auto‑completion, .gitignore usage, blame, log options, reflog, partial staging, interactive rebasing, stash, fsck, and cherry‑pick—to help you manage code efficiently, recover lost commits, and streamline your development process.
This guide walks you through the basics of GitHub, including creating an account, configuring SSH keys, creating repositories, cloning and pushing code, and contributing to other open‑source projects, with step‑by‑step screenshots to help beginners start using GitHub effectively.
This article explains three widely used Git workflows—Git flow, Github flow, and Gitlab flow—highlighting their feature‑driven development model, branch structures, step‑by‑step processes, advantages, drawbacks, and practical tips such as pull requests, protected branches, and commit squashing.
This article explains why teams should adopt Git, outlines its key advantages, discusses common version‑control challenges, and provides a detailed walkthrough of the Git Flow branching model—including production, develop, feature, release, and hotfix branches—plus practical command‑line examples and tool recommendations.
This article explains why many teams still use TFVC, compares its centralized features with Git's distributed advantages, and provides a step‑by‑step TFVC‑to‑Git migration procedure that retains full commit history and offers guidance on choosing the right repository strategy.
Team Foundation Server 2015 Update 1 introduces a range of enhancements—including dual Git/TFVC support, improved web version‑control UI, new Kanban board fields, integrated SonarQube analysis, multi‑selection in backlogs, customizable dashboards, advanced pull‑request features, and Azure resource‑group deployment—providing a richer ALM experience.
This guide presents seven practical Git command‑line techniques—including amending commit messages, resetting staged changes, reverting commits, checking out previous revisions, undoing merges, cleaning untracked files, and deleting branches—to help developers safely recover from common version‑control errors.
