heiwiper's website

Staging and Committing using Magit (Video)

heiwiper — Tue, 08 Sep 2026 08:00:00 +0100

Introduction

I have covered the Magit Status interface in my last post , which is the Magit equivalent of running git status. In this article I will go through two other very commonly used git workflows: staging and committing. Magit really excels at these, as we will see in the rest of this post.

Staging

Staging in Magit benefits from the intuitive Magit Status interface which adds a sense of responsiveness to the process. Staging or unstaging changes is instantly reflected in the same interface. It gives an impression of moving things around. Navigating through changes is as simple as moving the cursor around using the arrow keys, or the more efficient approach: using the keys n for next and p for previous to navigate through one change at a time.

I like to imagine the 3 sections Untracked files, Unstaged changes and Staged changes as a 3-shelf drawer where each shelf represents a section and the objects in the shelf represent the changes that we would move around.

The best part about staging changes in Magit is that we only press the s key to stage literally anything, whether it is a single line, a hunk, a whole file or all changes (we can also use the capitalized letter S or U to stage or unstage all changes). The only difference is where we put the cursor before we press the s key. Staging a part of a hunk requires selecting the lines that we want to stage. Unstaging is performed in the same exact way except that we use the key u for unstaging. In addition to that we can also discard changes in a similar way using the key k. All these shortcuts are displayed in the help buffer for discovery.

Committing

This Git command is essentially straightforward. The changes should be already staged at this point, and we just need to save them and add a message to describe changes. Magit improves this workflow by adding more workflows related to commits. Let’s first check the Magit Commit menu in the following image which appears when we press the c key.

Magit Commit menu appears in the bottom half of the screen.

We will start with my favorite command Instant fixup, before going over the menu sections.

The Instant fixup command takes staged changes and adds them to any existing commit. For example, let’s imagine we introduced a new API route in commit A and then made a couple of commits (B and C) on top. Later we review the commits for this API and decide to rename the route, but that commit is now a few commits back, the tip is C. The easy way to fix it is to add a new commit D; the cleaner way is to fold the change into commit A and rewrite the history from A through C. But rebasing creates friction, and one would avoid it if not strictly necessary. Instant fixup takes the clean approach and simplifies it: trigger the command, indicate the commit to add the changes to, and that’s it. This makes commits very forgiving, any commit can be altered in just a few keystrokes. I have previously read an article making this point, comparing how commits feel mutable in Jujutsu VCS compared to Git. In reality Git allows similar mutability; it’s just hidden behind a couple of commands, and users tend to work around such pain points rather than figure out the proper way to achieve what they want.

The Arguments section above provides some flags that can be toggled for very specific use cases. For example, let’s say at some point we would like to make sure Git hooks are not executed when we commit our changes, we would just press the key - then n. We can also notice how Magit highlights the actual Git CLI flags for each argument, which helps new Git users get familiar with the flags provided by Git and also helps experienced Git users ensure they are using the right flag.

The Create section contains a single command: the commit command itself. When invoked, the screen splits in half, with the commit message prompt on one side and the diff of the changes to be committed on the other. The following image shows the commit creation interface.

The commit message prompt and the diff of the changes to be committed.

The Edit HEAD section contains commands to modify the last commit in 3 different ways:

Extend: Adds the staged changes to the last commit
Amend: Adds the staged changes to the last commit and changes the commit message
Reword: Changes the last commit’s message

I will not go through the remaining commands since I don’t use them often, but if you are curious you can check the official documentation .

Conclusion

Staging in Magit is very simple yet very efficient. Because it feels like selecting text, the process is very intentional: you pick exactly the parts you want to stage, with no stray lines or whitespace cluttering the commit. Committing also feels efficient but in a different way. I like how the immutability barrier is not relevant. It gives the possibility to easily push commits that describe the flow of implementation of a specific feature. What I also like about Magit in general is how it remains faithful to Git by following the same terminology, it’s also possible to check each command that was executed by Magit by simply pressing the key $.

Emacs Chat with Sacha and Prot

heiwiper — Thu, 20 Aug 2026 19:46:44 +0100

Today I participated in the Emacs Chat series hosted by Sacha Chua and Protesilaos as a co-host. We explored my Emacs configuration . It was a very nice opportunity to share workflows and learn new things such as Emacs’s built-in input methods which I might use to write French and Arabic without the need to switch the system’s input method. I have also learned about an interesting workflow to sync transactions from my bank account to a ledger file using ledger-cli . Although I no longer use Emacs to keep track of my expenses, it’s a workflow that I would consider integrating into GnuCash .

After having this conversation on YouTube I am thinking about taking the opportunity to share my blog posts content on YouTube to practice speaking English and at the same time share my content in other formats for people who prefer audio/video content.

Sacha’s Blog post: https://sachachua.com/blog/2026/08/20-aout-emacs-chat-abdallah-maouche/

A Tour of Magit's Status Interface

heiwiper — Sat, 15 Aug 2026 20:43:46 +0100

Introduction

Magit is an Emacs Git client that is praised by many users . It was one of the reasons I switched to Emacs back when I stumbled across an Emacs video tutorial for the first time. I remember I was impressed by the intuitive UI/UX. In this blog post, I will go over the main Magit interface — Magit Status — and hopefully you will get to see why Magit is awesome .

Magit Status

This is the entry point interface that appears when you invoke Magit. It contains quite a lot of information, even if it doesn’t seem so at first glance. The following image is an example of the Magit Status interface:

There are two sections. The first displays four pieces of information — Head, Merge, Push, and Tag — which refer to:

Head — the last commit of your local branch
Merge — the remote branch you merge changes into
Push — the remote branch you push changes to (for example, a fork you contribute to)
Tag — the latest tag on your local branch, and how many commits you are ahead of it

The second section contains the recent commits, which are collapsed by default to avoid clutter. Here’s what the status interface looks like when you open the recent commits section using the TAB key:

This still doesn’t look like the a lot of information I described earlier, but the missing sections are just as informative: Magit only shows a section when it has something to report, and the lack of a staged or unstaged section here means nothing has changed.

In the following image, I modified the repository so these sections now appear:

First, the untracked files (collapsed by default). Second, the changed files under the unstaged section, including their changes (also collapsed). Third, the staged changes, similar to the previous section but containing only what was staged.

The interesting part about the Magit status interface is that it is interactive: you can stage or unstage changes, and add, delete, or hide untracked files. The list of possible interactions is far too long to cover here. To give you a better picture, it feels like piloting an airplane with the whole control panel within reach — except that here everything is at your fingertips. The following image shows that control panel:

The above image shows the Magit commands menu, which is hidden away and can be accessed using the ? key. It lists the commands available from the status interface, covering almost anything you would need, all accessible through a single key — and most are easy to remember because the first letter of the action is the shortcut key.

Looking back at the screenshots in this post, this single interface gives you the entire state of the repository while also providing all the commands you need, with excellent discoverability whether you are coming from the Git CLI or just starting out with Git through Magit.

Conclusion

The design behind Magit’s status interface never ceases to amaze me. I had planned to cover several other topics, such as how Magit approaches some Git workflows, but I found myself writing a lot about just the status interface, so I decided to keep this post short. In future posts I would like to write about simple workflows like staging, committing, and navigating between branches, as well as more advanced ones like cherry-picking and rebasing (which don’t feel advanced at all when you’re using Magit).

Still here? Good. Collect your cat.

Cat reward

Magit Is Amazing!

heiwiper — Wed, 15 Oct 2025 20:02:21 +0100

I’ve been hearing a lot about Jujutsu VCS lately, and when I say a lot I mean maybe 5 times this year. But that is a lot for a new VCS I would say.

The article I came across mostly goes through the flexibility of Jujutsu VCS over Git , or at least that’s as far as I managed to read before I lost interest. I was thinking “you can easily do this using Git???”, but then I realized that I’ve actually never used Git for almost anything besides cloning repositories… I’ve always been using Magit for almost everything.

Sometimes I think whether it would have been better if I started using Git CLI and then switched to Magit, that way I would really understand why it’s called that way, rather than taking all the amazing work behind it for granted. But I think afterall I wouldn’t have discovered Git commands so early in my career if I had just used the Git CLI from the start. I remember I was stashing my code changes back in my early career while other coworkers were struggling to move to another branch without losing their changes.

I’m pretty sure this isn’t all what Jujutsu is about, but now I really don’t feel like giving it a try anytime soon because of that article.

If you’re new to Magit, I walk through its status interface in A Tour of Magit’s Status Interface .

Still here? Good. Collect your cat.

Featured image for this post

My Journey to Personal Information Management

heiwiper — Thu, 22 Feb 2024 23:00:00 +0100

Introduction

Over the past few years, I have tried many tools and methods to manage my personal information in a way that I can trust my system to handle all the information I throw at it, without having to worry about forgetting an idea or an important event. I would always give up after a few days or a month at the most. Over time, I realised that I was trying to apply methods that worked for other people to myself, and that was the main reason why I didn’t stick with any of them. After that, I started keeping the ideas that seemed to work and trying to build my own workflow. That’s what I’m going to talk about in the rest of this post.

Capturing thoughts

Capturing thoughts is all about writing down whatever comes into your head and which is not actionable at the moment. This was largely inspired by David Allen, author of Getting Things Done. This method allows me to clear my mind and let go of thoughts that I would otherwise have to remember until I get a chance to either process them or store them somewhere that was inaccessible at the time the thought came to me.

The problem with capturing thoughts is that sometimes the effort required to capture the thought is greater than the effort required to simply keep the thought in your mind, even if you’re aware that you may eventually forget it.

To overcome this problem, it is important to choose the right tool. Personally, I always go for smartphones, even though I usually prefer to keep my personal information in plain text. But when it comes to capturing thoughts, the data is usually stored temporarily. I would have to move it somewhere else anyway.

It is also important to choose the right application with the least amount of resistance. The one I use is P!n .

It’s a very minimalist Android app that I’ve been using for a couple of years now. I have never lost a note while using this app and the features it offers are all that I need. I have tried other apps such as Pinnit which offers very similar features to the former, plus extra features such as setting reminders. But the fact that I have to go into the app to write the note is a deal breaker for me.

Managing habits

Habits are any tasks I have to do on a regular basis. They can be as simple as daily routines like brushing my teeth. In addition to these daily routines, I like to add other productivity habits that I want to make part of my day, such as reading books.

I think the most important thing about managing habits is reminders and history. There are many tools that can provide this, even notebooks can be used to track habits. I honestly haven’t tried many tools, I’ve been using the Android app Loop Habit Tracker for a couple of years now and I find it ticks almost all the boxes for me. The habits can be measured if necessary, the interface is very intuitive and offers useful graphs to keep track of your history. The notifications are persistent, so they don’t disappear until I check that I’ve completed the task. And there’s a bonus: the checkmark widget, which allows me to check my habits from the home screen. I only use it for measurable tasks because I have to update it several times a day. The only problem I have with this app is that I lose my habit notifications every time I restart the phone, which doesn’t happen very often.

Bullet journal

I used to think that I would never stick to a non-digital way of keeping track of tasks, notes, events… I mean, we have smartphones and computers for that now. It just didn’t make sense to leave all the features of modern apps like reminders and filters for pen and paper. But now that I have given it a fair chance (5 months so far), I think it serves a good purpose, at least for me. It’s not life-changing or anything like that. But mostly it has helped me get into the habit of checking in with myself. When it comes to self-discipline, that turned out to be what I lacked the most.

I think what is most important about the bullet journal is the practice that is built around it. It’s about reviewing everything you write in a timely manner, which has the benefit of weeding out anything that doesn’t matter as time goes on. I’m still thinking about applying this method in a digital way, but for now I like that it works well enough for my everyday life, so I’ll stick with it for this year at least.

Conclusion

That will be all for this article. I wanted to talk about another tool, but I think it deserves its own post, so I will leave it for another time.

Still here? Good. Collect your cat.

Featured image for this post