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.
Using Lerna, the article shows how to convert a multi‑package JavaScript project into a production‑ready monorepo by initializing Lerna, hoisting dependencies, automating versioning and publishing, integrating commit‑linting, code‑style tools, Babel builds, and VSCode debugging for streamlined development.
This article explains how to set up incremental code coverage for PHP applications by installing Xdebug, leveraging Git diff to identify changed files, and extending php-code-coverage to generate reports that highlight coverage gaps in newly added code, thereby improving test efficiency and reducing manual effort.
This guide walks Java developers through the key differences between IntelliJ IDEA and Eclipse, explains why IDEA eliminates the workspace concept, and provides step‑by‑step instructions for configuring default project settings, JDK, Maven, version control, auto‑import, Tomcat, shortcuts, and other productivity features.
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.
Discover a concise guide to essential backup solutions—including Git version control, Rsync command-line syncing, Dropbox cloud storage, and macOS Time Machine—explaining their core features, practical usage, and how they collectively safeguard your files, code, and system data.
This guide reviews four practical backup solutions—Git for versioned file control, Rsync for command‑line incremental syncing, Dropbox for cloud‑based GUI storage, and macOS Time Machine for full system snapshots—explaining their key features, typical use cases, and basic setup steps.
This guide walks you through five practical PyCharm techniques—including one‑click profiling, built‑in Git integration, automatic tab‑to‑space handling, and quick source‑code and docstring previews—to boost your Python productivity and streamline your workflow.
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.
A major bank transformed its legacy vendor‑managed .NET/Oracle applications by automating data‑patch deployments through Git, Jenkins, and custom database tools, enabling weekday releases, reducing manual effort, cutting overtime, and achieving continuous delivery despite outdated systems.
The article explains that selecting a Git branching model—Git‑flow, GitHub‑flow, or Gitlab‑flow—depends on a team's engineering capability and collaboration discipline rather than size, describing each model’s suitability, trade‑offs, and real‑world examples such as Facebook’s trunk‑based delivery.
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.
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.
Meituan’s client team solved the complexity of weekly transportation‑app releases by discarding the long‑lived develop branch, creating per‑week Release branches from a continuously integrated Stage branch, and automating multi‑repo branch creation, synchronization checks, and bulk merges with Jenkins, enabling fast, reliable deployments across 16 repositories.
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.
This guide explains how to configure a single computer to use multiple Git accounts by generating distinct SSH keys, setting up a custom SSH config file, adding the keys to each platform, and cloning repositories with account-specific credentials.
This article explores the challenges of iOS code coverage, explains the generation of .gcno and .gcda files using LLVM, and presents a transparent, Git‑aware incremental coverage solution that integrates into the development workflow with minimal overhead.
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 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 analyzes the challenges of dual‑mode (waterfall + agile) software development in traditional enterprises and proposes a full‑scenario Git branch management model—including Master, Dev, Test, feature, release and hot‑fix branches—while also announcing a DevOps+LIVE technical livestream about the 2018 Global DevOps State of the Union report.
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 tutorial walks you through creating a dedicated git user, configuring a bare repository, setting up SSH key authentication, installing GitLab on CentOS 7, managing groups and permissions, and performing backup and restore operations, all with concrete command examples and screenshots.
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 presents a step‑by‑step guide on using Git in a collaborative development workflow, covering project setup, creation of remote and personal branches, commit cleaning with rebase, merging branches, and final integration into the main branch to maintain a clean history.
This guide walks through configuring SSH keys, preparing a PHP webhook script, setting up Nginx, linking Coding and GitHub repositories, and troubleshooting common issues to achieve fully automated code deployment on an Ubuntu server.
The article describes a low‑cost solution that uses Git hooks and a custom CLI tool to automatically embed work‑item IDs from branch names or interactive selection into commit messages, enabling seamless traceability between code commits and requirements or defects and simplifying automated testing and team collaboration.
This guide explains the importance of a unified Git commit message format, details the type‑scope‑subject convention, shows how to fix invalid commits with interactive rebase, demonstrates integrating the validate‑commit‑msg tool and generating changelogs, and highlights the practical benefits for team collaboration and project maintenance.
Through a series of candid developer anecdotes—ranging from accidental production database truncations and hidden mistakes to the dangers of coding while exhausted and the importance of version control—this article highlights practical lessons for safer coding practices, rigorous reviews, and disciplined operational procedures.
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 report details a joint initiative by the Application Development Department and the PMO to improve software delivery efficiency through a full‑process continuous delivery methodology, a Git‑based configuration‑management model, and end‑to‑end pipelines applied to the multi‑scenario C3 project group, including results, advantages, training, and future plans.
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.
This step‑by‑step guide shows how to access the terminal in Ubuntu, install VMware Tools, switch to faster domestic apt mirrors, and add essential development packages such as vim, git, and gcc/g++ to turn a newly installed VM into a ready‑to‑code environment.
This week’s tech roundup covers ZTE’s business resumption, the performance‑boosting Git protocol v2, new features in JDK10, Amazon’s lead in global R&D spending, and Facebook’s venture into custom AI chips for video analysis.
The article explains how to turn a map service into an independent PHP library using Composer by creating a separate Git repository, configuring composer.json in both projects, autoloading via PSR‑4, managing dependencies, organizing code into configs, contracts, models, and custom exceptions, and highlights Composer’s advantages over Git submodule approaches for versioning and scalability.
This article describes how the Agricultural Bank's Software Development Center Department 2 adopted agile practices from 2017, using Kanban stand‑ups, Scrum, Git Pull Requests and CI/CD to build a continuous delivery pipeline, illustrating a six‑month journey from no agile knowledge to a self‑organizing, continuously improving team.
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.
This article explains why Git on Windows often displays garbled Chinese characters in tools like Git Bash, CMD, PowerShell, and IDEs, and provides step‑by‑step solutions—including Git config changes and environment variable adjustments—to enforce UTF‑8 encoding and eliminate the problem.
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 explains two methods to overcome Git authentication errors on Windows—configuring Git Credential Manager for Basic authentication and generating SSH keys—to securely connect to TFS/VSTS Git repositories, including required commands, setup steps, and credential storage details.
This article chronicles the development of a DevOps documentation hub from its early v0.5 prototype through v1.0 and v2.0 releases, detailing the shift from reStructuredText to Markdown, the use of Git submodules, Azure App Service deployment, and plans for automated navigation and community interaction.
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 article presents a comprehensive checklist of personal‑level DevOps tools—including JDK, Git, Docker, Maven, Jenkins, Ansible, ELK, and Trello—providing download links, basic usage commands, and verification steps so engineers can install, configure, and validate each component on Windows, macOS, or Linux.
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 reviews the key Windows-based DevOps tools, covering major IDEs such as Visual Studio, Visual Studio Code, and PowerShell Studio, as well as source‑control solutions like Microsoft TFS/VSTS and Git/GitHub, to help teams adopt DevOps on the Windows platform.
Over nearly two years, the author chronicles the transition of their development team from using TFS 2010 and manual processes to adopting Git, automated build and release pipelines, QA branch workflows, and Release Management in TFS 2015 Update 2, highlighting the resulting improvements in collaboration, deployment speed, and overall DevOps maturity.
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 walks through creating a Spring Cloud Config server backed by a Git repository, configuring it, exposing configuration via REST endpoints, and building a Spring Boot client that retrieves and binds those configurations, complete with code snippets and URL patterns.
The article describes how Microsoft migrated its Windows development codebase to a single 300 GB Git repository containing 3.5 million files, the challenges this scale created for Git, and how the Git Virtual File System (GVFS) was developed and open‑sourced to address performance issues.
This article explains how to transform raw Git diff output into a structured JSON format, handle various diff headers, and apply line‑by‑line highlighting using the diff‑match‑patch algorithm, while also offering performance optimizations for long lines.
This tutorial explains what Git hooks are, how to install and configure them, and provides a complete example of using a post‑update hook on a bare repository to automatically deploy a blog whenever code is pushed.
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 compares the CI/CD pipelines and Git branching models of two micro‑service projects, highlighting their deployment workflows, automation levels, visualisation, feedback speed, and trade‑offs to help developers and operations engineers choose an appropriate strategy.
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.
The TFS 2017 update introduces a completely redesigned branch page with a "mine" view, a revamped pull‑request UI featuring enhanced diff, comment, and file tracking capabilities, new squash‑merge support, improved build and commit traceability, Git LFS file preview, code‑link sharing, and additional UI enhancements for a smoother DevOps workflow.
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.
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.
Linus Torvalds discusses the origins of Linux, the role of open‑source collaboration, the evolution of Git, his personal work habits, and the broader impact of open‑source software on technology, business, and future innovation in a candid TED‑style interview.
By defining data collection (event tracking) requirements in a structured JSON format and storing them in Git with a web interface that abstracts version control, teams can standardize identifiers, validate data formats automatically, track changes via commit logs, and streamline collaboration between product managers, developers, and testers.
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 guide explains how to set up Jenkins to automatically poll a Git repository, run cppcheck static analysis, process the XML results, and email the findings, including detailed configuration steps, command examples, and troubleshooting tips.
This comprehensive guide walks you through Git's origins, environment setup, installation, essential commands, workflow states, branching strategies, tag management, as well as detailed steps for deploying GitLab, using GitHub, and selecting client tools, all illustrated with clear diagrams and practical examples.
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 explains how to set up bi‑directional synchronization between public GitHub repositories and private VSTS (Azure DevOps) repos using VSTS CI pipelines, covering configuration steps, command‑line tasks, token handling, and common synchronization scenarios.
This guide walks through setting up a Jenkins CI server—including environment preparation, installation, essential plugins, system and project configuration, security hardening, and a custom shell script for automated deployment—providing a practical roadmap for reliable continuous integration and delivery in Java projects.
Linus Torvalds, who created Linux as a hobbyist student and later Git, attributes their massive success to his lack of foresight, embracing openness and collaboration, which turned a free operating system into the backbone of servers, supercomputers, Android, and a thriving open‑source ecosystem.
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 outlines practical CI/CD and DevOps guidelines for startups, covering application management standards, branch strategies, code review tools, directory layout, permission controls, configuration change processes, release policies, logging practices, and automated deployment using tools like Git, Jenkins, and Ansible.
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.
Learn how to enable true 256‑color output in popular terminal applications such as Vim, mutt, slrn, git, man/less, ls, and grep, with configuration snippets and visual examples for terminals like xterm, urxvt, and iTerm.
This article chronicles the complete redesign of the BugHound bug‑submission system into UFT, covering data modeling with MySQL, migration from PHP/MongoDB to Node.js, progressive frontend upgrades from jQuery to Angular, schedule‑table algorithms, Git collaboration tactics, and future open‑source plans.
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.
