DEV Community: Cristian Zapata

Portable configurations with dotfiles and GNU Stow 🐧

Cristian Zapata — Wed, 22 May 2024 19:09:36 +0000

Since I started using Linux, I realized the great capacity it gives us as developers to interact directly with the system through the terminal. It's fantastic, but for very curious people like me, it can be a bit dangerous. Playing around in the terminal, I deleted something I shouldn't have and had to reinstall the operating system, a funny anecdote in my opinion. However, the issue changed when I had to reinstall all the applications I use and, on top of that, configure them from scratch.

Like everything in life, you have to see the good side of things and view everything as a learning opportunity. I started thinking, "Is there a way to save my configurations and apply them more easily?" And yes, it can be done, and today I'll show you how. But first...

What are dotfiles?

Simply put, dotfiles is a repository where we store all our configuration files for the applications we use daily. These files are usually hidden because they start with a dot (.), hence the name dotfiles.

We can also set up specific scripts for certain tasks or our aliases to improve our terminal workflow. If you don't know what an alias is or how to implement one, here is my blog on the topic for you to check out.

What will we need?

First of all, we must consider that usage and implementation vary from system to system, so in this blog, we'll see how to do it on our favorite penguin system 🐧.

Git and GitHub

As mentioned earlier, we will be working with a repository, so we will need Git to manage all our changes and keep track of the updates we make. Additionally, we need a place in the cloud to store them and have them available from any computer where we want to implement them, so I recommend GitHub.

Stow

This application, which is part of the GNU project, is the magic behind dotfiles as it will allow us to create symbolic links for our configuration files from our dotfiles to the configuration files originally in our system, ensuring they apply correctly.

IDE and Terminal

Lastly, we will need a terminal to run various commands for both Git and Stow and a text editor to make the different configurations we want in our applications. I recommend using Vi, Vim, or Neovim since they can be used from the terminal and unify the development process, but this is a personal choice.

Useful Commands

Here are some commands that will greatly help us achieve our goal and interact more easily with our file system from the terminal. Something to consider is that these commands work for Unix-based systems like Mac and Linux.

Move to a directory

cd folderName

Go back to the previous directory

cd ..

Move to the home directory

cd

Create a directory

mkdir folderName

Delete a directory

# If it's empty
rm folderName

# If it's not empty
rm -rf folderName

List the contents of a directory with a detailed format, including hidden files (only works with directories).

# Affects the current directory
ls -la

# Affects the specified directory
ls -la /folderName

View the content of a file

cat fileName

Create a file

# Usando touch
touch fileName

# Usando vim
vim fileName

Delete a file

rm fileName

Development

Now that we know everything we'll need, we can begin our mission. The first thing we need to do is create the folder for our dotfiles in our home directory.

mkdir $HOME/dotfiles

Now we need to initialize a repository in our dotfiles directory.

# Move to the directory
cd dotfiles

# Initialize the repository
git init

Now we run the git status command to check the status of our repository. It should look something like this:

On branch master

No commits yet

nothing to commit (create/copy files and use "git add" to track)

At this point, we can push our repository from local to remote, following the guide on GitHub.

Before using Stow, we need to ensure that the structure of our dotfiles matches the structure of the configuration files as they are by default in our system.

Also, the files we want to link cannot exist in the destination before running the stow command, as trying to create the link will result in an error. To fix this, we will delete the files in our destination, which is our home in this case.

rm fileName

Or, as a personal recommendation, you can rename them instead.

mv fileName.txt fileName.back

With this done, we run our command to create the links. It's very important to run the command from the main dotfiles folder.

stow .

Now we can go to our home directory to verify if the links were created correctly. We can check this by listing our files and seeing something like this:

Here we can see how our init.lua file in our home is linked and taking the content from our init.lua in our dotfiles.

With this setup, we can start adding all the configuration files for our applications, scripts to run when needed, or anything we can imagine. You can make your dotfiles whatever you want.

When you switch systems and want to apply your configurations, you just need to clone the repository in the home, rename the default files, and run stow from the dotfiles.

Thank you!

I hope this helps you as much as it has helped me to have my configurations always at hand and gives me great flexibility to work on any system I want.

Here are my dotfiles so you can have an idea of how I'm working on them, and of course, any improvements are welcome :).

If you found this interesting or know someone who might benefit from this, don't hesitate to share it. It would help me a lot.

And finally, if you want to contact me, don't hesitate to say hi on Instagram or GitHub.

Blessings, folks!

Simplify your terminal commands

Cristian Zapata — Mon, 22 Apr 2024 16:16:23 +0000

As a fellow developer, I'm sure you've found yourself navigating your terminal to manage files, run scripts, or handle git commands. And let's be honest, some of these tasks can be pretty repetitive, right? Ever wondered, "Is there a faster or easier way to do this?" If not, I bet you will eventually. And that's where this blog comes in handy. Today, I'll show you how to level up your workflow with some terminal tricks.

Take, for instance, being in your system's home folder:

theposintech@cristian in ~
👾

Now, imagine wanting to move to your project folder located at home/Documents/development/projects/myRust_app. Typing out that entire path every time is a drag. Or consider committing changes to your project. It's a whole process, right? But guess what? You can create custom shortcuts for these tasks using something called alias.

What is an alias?

An alias is like a cheat code for your commands. It lets you create shortcuts for lengthy commands, making them quicker to type and easier to remember.

Here's how you structure an alias:

Now, how do we put this into action? Well, we need to move into our shell 🐚 configuration file. In my case, I'm using zsh, so I'll head over to ~/.config and open up nvim .zshrc. If you're using bash, it's .bashrc.

In this file, we'll use the alias property to assign a name to our new command and specify the command it should run.

alias gst="git status"

Save the changes (in neovim, :w to save and :q to close) and then run this command in your terminal (if you're using zsh like me):

exec zsh

Now, you can run your new command in the terminal. But what if you need your alias to do something dynamic, like prompting you for input? Say, when you're committing changes and need to specify a message. In that case, you can define an input for your alias like this:

alias gcm='git commit -m "$reach: $*"'

Then, when you use it in your terminal, you'll replace those parameters with your messages.

gcm feat terminal workflow improved!

Where the final output will be "feat: terminal workflow improved!", Buut if we want to go forther we can use multiple commands in the same alias, let's to continue with our last example.

So, we've committed our changes. Now, let's push them to our repo with git push.

alias gcm='git commit -m "$reach: $*" && git push'

With the &&, the command on the right executes immediately after the left one finishes.

To consider

The alias we configure in our term will just work on our terminal (zsh), and if we want to use them in another one we have to configure them in that specific term too.

Thank you!

I hope this blog helps you streamline your console time and supercharge your developer productivity. If it does, don't hesitate to share it with your friends so they can level up too.

If you wanna share knowledge feel free on say hi on Instagram or GitHub.

Happy coding, folks!🐧

Mastering variable renaming with gn motion

Cristian Zapata — Thu, 18 Apr 2024 10:01:41 +0000

Imagine that we have a variable named myVar, and one of our teammates was reading our code and tell us that it's not descriptive at all but we've used it in numerous places throughout our code, and changing its name step by step isn't an easy task. This is where the "gn" motion snippet becomes incredibly useful. Let's explore how we can use it.

To begin, place the cursor above the word we want to rename in this case: myVar.

Then, press * to search for all instances of the word in the document and start working on it. This highlights all occurrences of the word, enabling quick navigation between them.

Next, press shift + n to move to the previous occurrence of the word in our document. Here, press g + n to operate on this occurrence, which is where the real magic happens. g + n allows for actions such as editing or renaming.

Now, press c to change the actual name and input the new one for our variable (this time, try that be something easy to understand), and then press Esc to finish editing that word. The Escape key exits the renaming mode, returning you to normal mode after inputting the new variable name.

Pressing n moves the cursor to the next occurrence of the word in the document, allowing for seamless continuation of the renaming process.

Finally, . repeats the last change made in the text editor. After renaming one occurrence of the word, pressing . applies the same change to the next occurrence, accelerating the renaming process.

Buuut there's another useful way to do this and is with the substitute command, let's check it out.

The first step is to exit any active mode by pressing the Esc key. Then, use the substitute command :s. As our intention is to rename all occurrences of our variable myVar, follow these steps:

So the final command will looks like this:

And if you're that curious as me, you might be wondering, What's the difference? or When should I use one or the other? Well, let me tell you with an example:

Suppose you have a variable named i for indexing purposes. In such cases, the "gn" motion is the preferred method for renaming. And this is because while the substitute command :s would alter all instances of i, including occurrences within words like function, int, if, void, size, and others, "gn" provides finer control. By navigating with the n key and applying the changes with ., you can selectively modify specific words.

So in conclusion use :s for terms that won't disrupt your code or when you want to modify all occurrences deliberately. And opt for the "gn" motion in scenarios with numerous occurrences, allowing you to selectively choose which ones to modify.

Now the next time you find yourself needing to rename variables or make widespread changes in your code you can do it faster and efficiently.

Thank you for read and I really hope this helps you to improve in Neovim, shared if you know someone else can be useful too, Blessings!.

Useful links:

Search and replace