Tagged articles
commit
52 articles · Page 1 of 1
This article details four ways to undo pushed Git commits: manual file comparison, git revert, creating a new branch from an old commit, and git reset with force push, explaining each method's workflow, safety trade-offs, and when to use which approach.
Gitbranchcommit
0 likes · 7 min read

This guide walks through Git's reset command, detailing the differences between --soft, --mixed, and --hard modes, when each is appropriate, and how they affect commits, the index, and the working tree for commits that haven't been pushed.
Gitcommitgit reset
0 likes · 5 min read

When you realize a recent Git commit has an incorrect message or missing files, you can safely amend the last commit using git commit --amend, provided the commit hasn't been pushed, avoiding the need for reset and keeping history clean.
Tutorialamendcommit
0 likes · 6 min read

The article explains that Git branches are lightweight pointers to commits, not full copies of the project, which makes switching, merging, and rebasing fast and cheap; it demystifies HEAD, merge, and rebase by walking through concrete commit graphs and examples.
GitHEADbranching
0 likes · 9 min read

This step‑by‑step guide walks developers through essential Git commands—from initializing a repository and checking status to staging, committing, branching, merging, stashing, and pushing changes—providing clear examples and code snippets for everyday version‑control workflows.
GitTutorialbranching
0 likes · 10 min read

Learn how to safely manage PostgreSQL transactions using DataGrip by understanding ACID principles, executing BEGIN, COMMIT, and ROLLBACK commands, handling errors, and applying practical tips for visibility, connection loss, and Docker deployments, all illustrated with step‑by‑step screenshots.
ACIDBEGINDataGrip
0 likes · 9 min read

This article walks through eight typical Git problems—missing branches, unwanted merges, unfinished work, wrong commit messages, early‑stage fixes, mass commit squashing, and recovery after mistakes—showing how to use rebase, cherry‑pick, stash, revert and related commands to resolve them efficiently.
cherry-pickcommitrebase
0 likes · 21 min read

This article explains comprehensive Git workflow, branch naming conventions, commit message standards, and supporting tools such as validate-branch-name, Husky, Commitizen, and Commitlint, providing practical examples and configuration snippets to help development teams maintain a clean and efficient version‑control process.
DevOpsGitTools
0 likes · 12 min read

This article explains the hidden .git folder structure, detailing each file and directory such as HEAD, refs, objects, logs, config, index, and hooks, and shows how to read commit data and use stash with practical command examples.
CONFIGGitcommit
0 likes · 8 min read


21CTOApr 18, 2024 · Fundamentals
This comprehensive guide walks developers through Git fundamentals—including branches, commits, tags, staging, remote repositories, conflict resolution, popular workflows, and advanced commands—while providing practical code snippets and a handy cheat‑sheet for everyday version‑control tasks.
Gitbranchingcommand-line
0 likes · 18 min read

This article explains the internal steps InnoDB performs when committing a transaction, covering undo segment caching, generation of the transaction commit number, state changes of insert and update undo segments, history‑list insertion, and the final reinitialisation of the transaction object.
Database InternalsInnoDBMySQL
0 likes · 12 min read

This article explains how MySQL 8.0.32 processes the flush, sync, and commit subphases during a two‑phase commit, detailing the roles of leader and follower threads, log handling, system variables, and the conditions that trigger binlog rotation and persistence.
InnoDBMySQLbinlog
0 likes · 10 min read

This article walks readers through Git’s internal architecture, explaining the .git directory layout, object storage, staging area, and how low‑level commands like git hash-object, write‑tree, and commit‑tree build commits and branches.
Gitcommitgit internals
0 likes · 14 min read

This guide explains how to keep your Git log tidy by using git commit --amend to modify the latest commit, interactive rebase to squash or fixup multiple commits, and pull with --rebase to maintain a linear history before merging feature branches.
GitLog Cleanupamend
0 likes · 9 min read

This guide demystifies Git’s inner workings by walking through repository initialization, the structure of the .git directory, how objects, blobs, trees, and commits are created, and the roles of the index, HEAD, branches, and remote configuration, complete with commands, examples, and visual diagrams.
GitRepositorybranch
0 likes · 24 min read

This guide explains how to correct an incorrect author email in Git commits—both for the most recent commit and for the entire history—using amend, filter‑branch scripts, and how to handle existing backup references.
GitScriptauthor
0 likes · 3 min read

This article explains the inner workings of Git by detailing what occurs during initialization, adding files, committing changes, managing branches, and interacting with remote repositories, covering the .git directory structure, objects, SHA‑1 hashing, the index, HEAD, refs, and push operations.
GitHashObjects
0 likes · 22 min read

This guide explains why commits may contain an incorrect corporate email, shows how to amend the most recent commit or batch‑rewrite the entire history using git commands and a filter‑branch script, and addresses a common backup error during the rewrite process.
Gitamendauthor
0 likes · 5 min read

This article explains how to use Git commands to obtain the current commit author, active branch, list of unpushed commits, and the files changed in each commit, and concludes with a promotional notice for a PHP online training class.
GitUnpushed Commitsbranch
0 likes · 7 min read

This guide explains Git's core commands—including add, commit, reset, checkout, diff, merge, cherry-pick, and rebase—covers staging, branching, detached HEAD handling, and the underlying storage model, providing a comprehensive overview for developers seeking to master version control.
Gitbranchingcheckout
0 likes · 9 min read

This guide walks through essential Git commands—including add, commit, reset, checkout, merge, cherry-pick, and rebase—explaining their effects on the working directory, index, and repository, while covering concepts such as HEAD, detached HEAD, and the underlying object storage.
Gitcheckoutcommand-line
0 likes · 11 min read

This article provides a visual, step‑by‑step guide to the most frequently used Git commands, explaining basic operations like add, commit, reset, and checkout, and detailing advanced actions such as diff, merge, cherry‑pick, and rebase, while illustrating concepts of blobs, trees, and HEAD states.
Gitbranchcommit
0 likes · 9 min read

This comprehensive guide explains Git’s core concepts—including its distributed advantages, file states, commit nodes, HEAD, and remote repositories—while detailing practical commands for committing, branching, merging, rebasing, cherry‑picking, reverting, and synchronizing with remote servers, all illustrated with clear diagrams and examples.
Gitbranchingcommit
0 likes · 18 min read

The article examines how a large transaction in MySQL 5.7 can block the SHOW MASTER STATUS command by holding the lock_log during the commit's flush stage, analyzes the commit and SHOW MASTER STATUS code paths, and proposes mitigation strategies such as avoiding big transactions and using SELECT @@global.gtid_executed.
MySQLbinlogcommit
0 likes · 7 min read

An AOSP commit proposed by a Xiaomi engineer to prohibit shell extraction of installed APKs—citing potential IP leakage—was rejected after receiving only the author’s support and two opposing votes, with reviewers arguing that such restrictions are ineffective, could be bypassed, and should be handled via DRM or device‑specific policies.
AOSPAPKDRM
0 likes · 3 min read

This comprehensive guide explains Git's core concepts—including advantages, file states, commits, HEAD, and remote repositories—covers branching strategies, and provides detailed command references for adding, committing, resetting, checking out, merging, rebasing, cherry‑picking, and synchronizing with remote servers.
Gitbranchingcommit
0 likes · 16 min read

This article provides an in‑depth tutorial on Git, covering its advantages over centralized systems, file states, commit nodes, HEAD, remote repositories, branching strategies, detailed command usage for committing, branching, merging, rebasing, cherry‑picking, and rollback, as well as practical tips for effective version control.
Gitbranchingcommit
0 likes · 18 min read

This comprehensive guide covers 45 common Git scenarios—including committing, amending, resetting, rebasing, stashing, and branch manipulation—providing clear command examples and step‑by‑step instructions to help developers efficiently manage code changes and resolve typical version‑control challenges.
Gitbranchcommit
0 likes · 32 min read

This article presents a detailed collection of 45 everyday Git operations covering commits, amendments, branch management, staging, rebasing, merging, stashing, and recovery techniques, providing clear command examples and explanations to help developers handle typical version‑control tasks efficiently.
Gitbranchcommit
0 likes · 28 min read

This article demystifies Git by explaining the internal structures created by commands like git init, git add, and git commit, detailing the .git directory layout, object types, SHA‑1 hashing, the index, branches, HEAD pointers, and how remote repositories are linked and synchronized.
branchcommitgit internals
0 likes · 22 min read

This article explains the fundamental Git commands for adding, committing, resetting, checking out, and managing branches, along with detailed descriptions of diff, commit, checkout, reset, merge, cherry-pick, and rebase operations, providing visual illustrations and practical usage tips.
Gitbranchcommit
0 likes · 10 min read

This article walks through the inner workings of Git, explaining how initializing a repository creates the .git structure, how objects, blobs, and SHA‑1 hashes store file contents, the roles of the working directory, index, and commit objects, and how branches, HEAD, and remote connections operate together to manage version history.
BLOBGitRepository
0 likes · 21 min read

This article explains how Git works internally by describing the .git directory layout, the creation of blob, tree and commit objects during init, add, and commit operations, and how branches, HEAD, remote configuration, reflog, and diff commands manage version history.
GitObjectsRepository
0 likes · 20 min read

This article demystifies Git by explaining how the init command creates the .git directory structure, how objects, blobs, and SHA‑1 hashes store file contents, the role of the index, the mechanics of add, commit, branch, HEAD, remote linking, push, reflog, and diff operations, all illustrated with command‑line examples and diagrams.
Repositorybranchcommit
0 likes · 23 min read

This article provides a comprehensive guide to Git's core commands—including add, commit, reset, checkout, merge, rebase, and cherry‑pick—explaining their effects on the working directory, index, and repository, as well as visualizing branch relationships and HEAD states.
branchcommand-linecommit
0 likes · 10 min read

This guide explains how Git’s core commands move files among the working directory, staging area, and repository, covering add, commit, reset, checkout, diff, merge, rebase, cherry-pick, and related concepts, with visual diagrams and tips for interactive modes and detached HEAD handling.
branchcommitmerge
0 likes · 11 min read

This guide explains Git’s core concepts and basic commands—including add, commit, reset, checkout, merge, rebase, and cherry-pick—illustrated with diagrams that show how files move between the working directory, index, and repository, and how branches, HEAD, and detached states operate.
Gitbranchcheckout
0 likes · 11 min read

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.
Gitbranchcommands
0 likes · 9 min read

This article explains how Elasticsearch handles data ingestion, retrieval, and full‑text search by describing the roles of coordinating, primary, and replica nodes, the refresh‑commit‑flush cycle, segment files, translog, and the Lucene‑based inverted index that powers its near‑real‑time capabilities.
ElasticsearchInverted IndexLucene
0 likes · 11 min read

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.
Gitbranchingcommand-line
0 likes · 11 min read

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.
ObjectsRepositorycommit
0 likes · 13 min read

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.
Gitamendcommit
0 likes · 5 min read

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.
branchcommitmerge
0 likes · 20 min read


ITPUBDec 25, 2019 · Fundamentals
A four‑year‑old girl submitted a one‑character patch to the Linux kernel that added a dash for proper alignment, illustrating the openness of the kernel project, the meticulous nature of its codebase, and the surprising impact of even the smallest contributions.
FormattingLinuxOpenSource
0 likes · 3 min read

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.
BLOBGitcommit
0 likes · 11 min read

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.
Gitbranch recoverycommit
0 likes · 5 min read

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.
Gitbranchcommit
0 likes · 19 min read

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.
Gitbranchcommit
0 likes · 9 min read


DevOpsJan 21, 2018 · Fundamentals
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.
Gitbranchingcommit
0 likes · 11 min read


DevOpsJan 9, 2018 · Fundamentals
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.
CollaborationDistributed SystemsGit
0 likes · 12 min read

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.
Gitbranchcommand-line
0 likes · 13 min read


ITPUBNov 27, 2015 · Fundamentals
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.
Gitbranchcleanup
0 likes · 8 min read
