DEV Community: Samar F. Jaffri

Git Log Tips: Find Commits Easily and Quickly

Samar F. Jaffri — Sat, 27 Jul 2024 05:47:11 +0000

git log;

Following my last blog you can access below;

Beginner's Guide to Git Commands

Samar F. Jaffri ・ Jul 26

Today I will share some Git log commands that will be helpful to you in your VCS journey.

If you’ve read my previous article, you’re already familiar with Git and its usage. For those who haven’t, Git log is a powerful command that allows you to review the commit history in a Git repository and offers various options to filter out the commit messages based on your needs.

Now without any further delay, let’s jump to the git log options

Let’s dive into git log options!

Log all

First and foremost, Git log command is used to list all the commit messages of the branch including the information about the commit author and date of commit along with the commit hash and message.

# log all commits
git log

If you don’t know what branch is, don’t worry we will discuss it in upcoming articles.

Filter the Commits

Get n commits

You are least likely to use this option since by default Git provides only the commit messages that fit into your terminal. But if you anyhow still want to get a specific number of commits only you can do so by using -n option.

# show the last 5 commits
git log -n 5

Filter commits by Date

You can also filter commits based on when they are committed. Git provides you with the option to filter the commits after the specified date using --since, --after, and to get the commits before the specified date using --until, and --before.

Also, these commands work with both specific and relative dates.

# show commits from the past two weeks
git log --since="2 weeks ago"
# or by using --after
git log --after="2 weeks ago"

# show commits until January 1, 2024
git log --until="2024-01-01"
# or by using --before
git log --before="2024-01-01"

It is also recommended that for consistent behavior you specify the timezone git log --date=local ...

Filter by Author

Sometimes you might want to filter the commits by author. I mostly need it to filter out my commits before the scrum meeting to prepare my status. But hey, it also has many good uses, which obviously doesn't include stalking another dev.

# get commits from a specific author
git log --author="Author Name"

Filter Commits based on Commit Messages

This is the most useful filter option that comes with Git log. If you follow a good commit message convention then this would greatly help you to filter specific types of commits like fix, build, ci, etc.

# show commits with "fix" in the message
git log --grep="fix"

Formatting Output

You can also format the log messages as it suits you by using the --pretty option.

Predefined Formats

oneline: Displays each commit on a single line.
short: Includes commit hash, author, date, and subject.
medium: Adds commit message and file changes.
full: Includes full commit information.
format: Allows custom formatting using placeholders (e.g., %H for commit hash, %an for author name, %s for subject).

# show concise logs
git log --pretty=oneline

# use --oneline for combining --pretty=oneline --abbrev-commit
git log --oneline

# custom format with short hash and subject
git log --pretty=format:"%h - %s"

Custom Formatting

Or you can create custom formatting by utilizing specifiers.

git log --pretty=format:"Commit: %H\nAuthor: %an\nDate: %ad\nSubject: %s\n\n%b"

Git log useful Specifiers

%H Commit hash
%h Abbreviated commit hash
%T Tree hash
%t Abbreviated tree hash
%P Parent hashes
%p Abbreviated parent hashes
%an Author name
%ae Author email
%ad Author date (format respects the --date=option)
%ar Author date, relative
%cn Committer name
%ce Committer email
%cd Committer date
%cr Committer date, relative
%s Subject

Viewing Commit Details

-p: Show the patch (diff) introduced by each commit.
--stat: Show statistics for each commit (added, deleted, modified files).
--shortstat: Show a summary of added, deleted, and modified files.

git log -p --stat

Other Useful Options

--graph: Display a commit graph.
--follow: Continue listing the history of a file beyond renames.
--reverse: Show commits in chronological order (oldest first).
--no-merges: Exclude merge commits.
--first-parent: Only follow the first parent commit of merge commits.

Combining Options

As I have mentioned above about --oneline, you can combine multiple options.

# get commits from "Author Name" formatted as "%h - %s" commited within a month
git log --author="Author Name" --since="1 month ago" --pretty=format:"%h - %s"

# find bug fix commits from last week
git log --grep="fix" --since="1 week ago" --pretty=format:"%h - %s"

Advanced Usage

Commit Ranges: Specify a range of commits using commit1..commit2 syntax.

Refspecs: Use refspecs like origin/master..HEAD to compare branches.

Filtering by File: Use --path to filter commits based on file paths.

Interactive Rebasing: Use git rebase -i to edit commit history.

Cherry-Picking: Use git cherry-pick to apply specific commits to another branch.

Reference:

Beginner's Guide to Git Commands

Samar F. Jaffri — Fri, 26 Jul 2024 02:15:21 +0000

Basic Git commands every novice should know

We’re all familiar with the importance of version control systems in today’s world. Nobody wants to go through the hassle of debugging an issue, and getting the code to work perfectly, only to mess it up while making some tweaks.

When it comes to version control systems, who isn’t familiar with Git? One of the most widely used version control systems out there! Git is an open-source distributed version control system that assists developers in keeping track of their project changes.

Speaking of the significance of Git, today I will walk you through some basic Git commands that could save you time and make your work feel effortless. Let’s go…

Setup

Setup Credentials

While starting up with git one of the first things to do is to set up your credentials.

# --global will set the credentials globally in your system
git config --global user.name "Your Name Comes Here"
git config --global user.email "you@yourdomain.example.com"

Note: If you use a web-based hosting service for Git repositories i.e., GitHub, GitLab, etc. Specify those credentials in git.

Setup Default Primary Branch Name

Both Git and GitHub have recently undergone some changes. While the primary functionality remained the same the convention of calling the primary branch “master” has now shifted, and newer repository primary branches are called “main”.

Depending on your organization or personal preference, if you need to set your default branch it can be done as follows,

# setup default branch
git config --global init.defaultBranch main

Basics

Cloning an Existing Repository

If you’re using a web-based VSC service, you’ll need to clone the repository to your computer to start working.

# clone the remote repository on your system
git clone https://github.com/user-name/repo-name.git

Initializing a Repository

If you’re getting your project started locally, you’ll need to initialize Git in your project to utilize the Git version control system.

# initialize a git repository
git init

Stage Changes

After you’ve initialized or cloned a repository, you can begin making changes to the code. When you’re ready to save the changes, you need to stage them.

But what is staging?

As per the official guidelines, Git has three stages: modified, staged, and committed.

Modified means that you have changed the file but have yet to commit it to your database.
Staged means that you have marked a modified file in its current version to go into your next commit snapshot.
Committed means that the data is safely stored in your local database.

So when you are done with the changes, stage them.

# to stage a specific file; always mention file_name with the extension
git add file_name.ext

# if you want to stage all changes
git add .

# you can also stage a folder
git add folder_name/

# wildcards can also be used
git add *.ext

Commit Changes

Staged changes are not secure, meaning that staging doesn’t create a version in the history. It simply acts as a stage between your commits and local changes. To save changes in history, you need to commit them.

# commit the changes and specify the commit message by -m
git commit -m "commit message goes here"

# you can also style the commit message as a summary and details
git commit -m "commit summary" -m "commit message goes here"

You can simply use git commit and specify the message later in vim. However, I prefer using -m as it saves me some time.

Changing the Commit

If you forget to add some files to the commit, or you want to make more changes to the files after committing them, don’t worry. You can simply amend those changes in the commit.

Just make changes, stage them using git add, and then amend them.

# add changed to last commit
git commit --amend

Check Status

Have you ever had a moment where you suddenly forgot if you saved a file while working? This can happen while using Git too. For those moments, we have status command.

# check the status of all files
git status

It will show you the status of all your files, so you can quickly get back to your work or save the changes you haven’t saved yet.

Check Difference

The git status shows you the status of all the files, but if you want to compare the content of a file, you can check the difference.

# check the difference between all files
git diff

# check the content of a specific file
git diff file_name.ext

# check the content of a specific folder
git diff folder_name/

You can also view staged changes. Remember: staging contains what will go into your next commit.

# check staged changes
git diff --staged

# check the content of a specific file
git diff --staged file_name.ext

# check the content of a specific folder
git diff --staged folder_name/

View the Commits History

After making numerous changes or collaborating on a remote repository (such as GitHub or GitLab), it often becomes crucial to review the commit history to track the progress. Git offers this functionality through logs.

git log

# you can also see just the summary of logs
git log --oneline

# you can also see the ASCII graph of the branch and log history
git log --graph

Now, Git Logs requires a separate article. However, I am sharing the commands that will be useful in many situations.

In addition to the above commands, you may find the limit options to be helpful.

- Show only the last n commits.
-- since, -- after Limit the commits to those made after the specified date.
-- until, -- before Limit the commits to those made before the specified date.
-- author Only shows commits in which the author entry matches the specified string.
-- committer Only show commits in which the committer entry matches the specified string.
-- grep Only shows commits with a commit message containing the string.
-S Only shows commits adding or removing code matching the string.

Pushing Changes

If you are working with a remote repository, remember that all the commits you have created using Git are just saved in your local system until you push them.

# push the changes to the branch
git push origin branch_name

Fetching Changes

When working with remote repositories, you might need to fetch the changes; repositories, and tags, that other developers have committed.

# fetch changes from origin
git fetch origin

Creating Tags

Tags come in handy when you want to highlight an important point in VCS. The most common use case is marking the release of the project.

There are two types of tags, Annotated tags and Lightweight tags.

Annotated tags are stored as complete objects in the Git database and include details such as the tagger’s name, email, and date. They also have a tagging message and can be signed and verified with GNU Privacy Guard (GPG). These are the recommended tags for significant points like releases.

# create an annotated tag
git tag -a v1.4 -m "initial release - version 1.0"

On the other hand, Lightweight tags are simply pointers to a specific commit and can be used for various other purposes.

# create a lightweight tag
git tag v1.4-lw

You can also verify the content of tags using the show command.

# see the content of a specific tag
git show tag_name

And once you are done, you can push the tag(s) to the remote repository.

# push a specific tag
git push origin tag_name

# push all local tags
git push origin --tags

Furthermore, you can list, delete, and checkout tags as needed.

# list all tags
git tag

# show additional information of a specific tag
git show v1.4

# delete a tag from the remote repository
git push origin --delete tag_name

# checkout to older version (tagged time) by creating a new branch
git checkout -b new_branch_name tag_name

Creating Aliases

Last but not the least, aliasing. Yup, you heard it right. Git allows us to create aliases for commands to make things easier using the git config command.

# aliase commit as cmt
git config --global alias.cmt commit

While there are numerous use cases for this, my personal favorite is aliasing the long commands associated with tags.

# aliase diff --staged command
git config --global alias.diffs 'diff --staged'

So now, whenever I need to execute the git diff --staged I can simply call git diffs.

And that’s all for today. While there’s much more to explore regarding logs, tags, and branching, we’ll save that for future articles since this blog is meant for beginners.

If you found the article helpful and learned something new, please give it a like. Feel free to share any suggestions in the comments section.

References

Unleash Python's Magic: The Craft of One-Liner Code

Samar F. Jaffri — Sun, 27 Aug 2023 22:03:28 +0000

Introduction:

Python is well-known for its clear and easy-to-read code, but there's one aspect that programmers find particularly fascinating: the one-liner code. This blog post will take you on a journey through the art of condensing complex functionality into a single line of Python code. We'll explore concise list comprehensions and elegant lambda functions, delving into their power, creativity, and efficiency. These one-liners can really pack a punch!

1. List Comprehensions:

The list comprehensions in Python are a great example of concise code. Turning loops into compact expressions, list comprehension allows for the creation and manipulation of lists in just one line of code.
Here is an example of generating a list of multiple of 2.

# ordinary way
multiples = []
for i in range(1, 10):
    multiples.append(i * 2)

# using list comprehension
multiples = [i * 2 for i in range(1, 10)]

2. Lambda Functions:

Lambda functions, also known as anonymous functions, allow us to create concise functions in a single line. They are especially handy for performing straightforward tasks.
Let's see an example of an add function.

# ordinary way
def add(x, y):
    return x + y

# using lambda functions
add = lambda x, y: x + y

3. Conditional Expressions:

With Python's ternary conditional expressions, you can use inline if-else statements to streamline your code. This results in a more elegant and concise code.
Let's take a simple example of finding if the number is even or odd.

num = int(input('Enter a number: '))

# ordinary way
if num % 2 == 0:
    result = 'Even'
else:
    result = 'Odd'

# using condition expressions
result = 'Even' if num % 2 == 0 else 'Odd'

4. Comma Operator:

As a Python developer, you'll find Python's Comma Operator to be an invaluable tool. It allows you to easily unpack iterables and swap values, saving both lines of code and memory.
Let's look at an example of swapping two variables.

a, b = 1, 2  # initializing two variables at once

# ordinary way
temp = a
a = b
b = temp

# using the comma operator
a, b = b, a

5. Extended Slicing:

Extended slicing in Python can perform some magical tricks within the code. It's applicable to both lists and string values.
Let's see how it simplifies palindrome checks by revering string in one line.

s = 'abcba'

# ordinary way
reverse_s = ''
for char in s:
    reverse_s = char + reverse_s
is_palindrome = s == reverse_s

# using extended slicing
is_palindrome = s == s[::-1]

6. Short Circuit Evaluation:

To return a value based on a condition, Short Circuit Evaluation is an effective approach. Python developers can use a one-liner code and employ and, or, or not for this purpose.
Let's see how we can use or for conditional expressions

val = 0
# ordinary way
if val:
    result = val
else:
    result = 'Default Value'

# using short circuit evaluation
result = val or 'Default Value'

7. Dictionary Comprehensions:

Similar to how we utilize list comprehensions, we can also form dictionaries through dictionary comprehensions.
Let's reuse the example of multiple of 2 for dictionary comprehension.

# ordinary way
multiples = dict()  # using dict() here as {} defines both empty set and dict
for i in range(1, 10):
    multiples[i] = i * 2

# using dictionary comprehension
multiples = {i: i * 2 for i in range(1, 10)}

8. Strings Concatenation:

In all programming languages, there is a basic feature known as string concatenation. Although it may seem like a simple concept, it can actually be utilized to convert a list into a string. This is why it has been included in this list.
Let's look into it by taking an example of a list of words.

arr = ['Python', 'is', 'amazing!']
# ordinary way
str = ''
s = ''
for item in arr:
    s += item + ' '

# using string concatenation
s = ' '.join(arr)

Downside of Using One-Liner

Although Python's one-liners can make code cleaner and more readable, overusing them can harm readability.
For instance, let's consider checking whether a number is positive, negative, or zero.

num = int(input('Enter a number: '))

# ordinary way
if num < 0:
    result = 'Negative'
elif num > 0:
    result = 'Positive'
else:
    result = 'Zero'

# using condition expressions
result = 'Negative' if num < 0 else 'Positive' if num > 0 else 'Zero'

In the example given, the conventional method is easier to understand than the one-liner conditional expression. Therefore, it is advisable to strike a balance between not using the one-liner and using it excessively, as both can impact code readability and even performance in certain situations.

Conclusion:

Python's one-liner code snippets showcase the language's adaptability and expressiveness. However, it's crucial to ensure that the code remains easy to read and not overly complex despite its brevity. One-liners, used wisely, can improve code efficiency, simplify tasks, and add a touch of coding elegance. Therefore, if you're faced with a long-winded solution, consider whether a clever one-liner could be the perfect solution for your code.