| Oct | NOV | Dec |
| 29 | ||
| 2020 | 2021 | 2022 |
COLLECTED BY
Collection: Common Crawl
Full Stack Python
All topics |
Blog |
Supporter's Edition |
@fullstackpython |
Facebook |
What's new?
Git is an implementation of the source control concept. Learn how these pieces fit together in the development environments chapter or view the table of contents for all topics.
git checkout -b and faster branch merging and clean up. In contrast
to earlier version control systems, Git encourages developers to create local
branches and experiment in them without impacting a stable master branch.
GitHub also helped to drive Git as the overwhelming
version control favorite by providing the open source community with free open
remote Git repositories. GitHub's web application user interface, issue
tracking and pull request features for maintainers and consumers also
encouraged more collaboration than Git alone. Recently,
GitHub's third-party marketplace has
begun to add more features by integrating
continuous integration servers like
as Jenkins and code metrics services.
git bisect,
git stash and git difftool.
git ready presents beginner, intermediate and
advanced tips for how to use Git. The example commands and their results
are great for learning Git piece-by-piece.
git checkout filename) and
"I want to rename a branch" (git branch -m newname).
Shadows Of The Past: Analysis Of Git Repositories
explains how you can extract some surprising data from Git repositories'
commit history, such as which developers are domain experts in certain
tools, potential hot spots in the code and coupling between source code
files. This is a great read once you get past the basics of using Git.
Write yourself a Git! is a tutorial for building
your own version of Git from scratch with 503 lines of Python code. The
result is obviously not as full-featured as the real Git implementation
but this program is awesome for understanding how Git's internals work.
Phil Nash shows how to use the git reflog command
in Git back to the future.
On undoing, fixing, or removing commits in git
is a fantastic overview of how to unscrew a whole slew of bad situations
you may find yourself in if you use Git for long enough.
High-level Problems with Git and How to Fix Them
is a long-form article on how to fork properly (and how not to use them)
and how to not go crazy using branches and remote repositories.
git log and related commands.
How to squash Git commits
explains how to use the git rebase command in interactive mode to
consolidated the number of commits in your history. This technique is
useful when a group of commits are related and it's easier to understand
them as a single commit rather than a collection of smaller commits.
Oh shit, Git! is a profanity-filled description
of tips to get you out of binds you may find yourself in when you get too
tricky with Git commands.
Tips for a disciplined git workflow
is less about workflow and more about how to write self-explaining commit
messages, self-containing each commit and modifying branch history
when you muff up before it is merged into master.
Another Git catastrophe cleaned up
goes through a difficult merge scenario that required deep Git
understanding to properly fix.
Erlang's source code provides a concise explanation on
writing good commit messages
that any programming ecosystem can learn from.
Git internals
is a presentation that covers how Git stores data, how to work with
the Git history, and good practices for using Git based on the
knowledge of how it works internally.
Chasing a bad commit
examines the git bisect command and how it can be used in either
interactive mode or on its own with git bisect run to find the
problematic code commit that needs to be fixed.
GitTips is a list of
pro tips to clean up common issues and how to dive through Git history
to find specific text.
Git allows command aliasing, which allowed one developer to create his
own list of lesser known Git commands
that alias more complicated Git lines.
Little things I like to do with Git
has some nice tips such as easily viewing branches you recently worked
on and generating a changelog from your commits.
Git from the inside out
demonstrates how Git's graph-based data structure produces certain behavior
through example Git commands. This is a highly recommended read after you've
grasped the basics and are looking to go deeper with Git.
How I configure my git in a new computer
shows how to handle a .gitconfig file, with
an example Gist
that the author uses for his own environment.
How to Quickly and Correctly Generate a Git Log in HTML
is an interesting look at how string processing on *nix systems works
by generating an HTML page from a Git log. If you need to output your
Git commits somewhere and are having trouble writing your own script
you should check out some of the interesting solutions the author
presents.
Better Git configuration
explains global config options, revisions and merging along with several
other commands that can be customized to your taste.
Why does Git use a cryptographic hash function?
explains that the SHA-1 hash isn't used for security on Git, it's a
consistency check. SHA-1 has been broken
in practice so Git needs to transition to a stronger hash without proven
collisions but it's not quite as big of a concern compared to
security-related projects that use SHA-1.
The anatomy of a git commit
digs into the tree and commit objects that underpin the Git source control
system. This is an awesome read to get a view on how Git works under the
commands you're using to manipulate these objects.
How to Undo Mistakes With Git Using the Command Line
is a video that covers topics like resetting a file to an old revision,
recovering deleted commits, squashing multiple commits into one with
interactive rebase and recovering deleted branches.
The most accurate speech-to-text API. Built for Python developers.