DEV Community: Sujit Kumar

Install AppImages on Arch Based Linux

Sujit Kumar — Tue, 11 Feb 2025 13:49:59 +0000

How to Install and Use AppImages on Arch Linux

AppImages are a great way to run applications on Arch Linux without installing them via the package manager. Unlike traditional packages, AppImages are self-contained, making them portable and easy to manage. However, to make them accessible via launchers like Rofi (drun mode) or dmenu, we need to set them up properly.

This guide will walk you through the manual installation of an AppImage and integrating it into your system so it appears in Rofi and dmenu.

Step 1: Create a Directory for AppImages

To keep things organized, store all AppImages in ~/.local/share/AppImage.

mkdir -p ~/.local/share/AppImage

Step 2: Download the AppImage

For example, to install Obsidian, download its AppImage:

wget -O ~/.local/share/AppImage/Obsidian.AppImage "https://github.com/obsidianmd/obsidian-releases/releases/latest/download/Obsidian.AppImage"

If you're installing another AppImage, replace the URL and filename accordingly.

Step 3: Make the AppImage Executable

Before running the AppImage, it needs to be marked as executable:

chmod +x ~/.local/share/AppImage/Obsidian.AppImage

If you're installing a different AppImage, replace Obsidian.AppImage with the appropriate filename.

To run the application:

~/.local/share/AppImage/Obsidian.AppImage

Step 4: Create a .desktop File

To make the application appear in launchers, we need to create a .desktop entry.

Open a new .desktop file in your local applications directory:

nano ~/.local/share/applications/Obsidian.desktop

Paste the following content:

[Desktop Entry]
Name=Obsidian
Exec=/home/$USER/.local/share/AppImage/Obsidian.AppImage %u
Icon=/home/$USER/.local/share/icons/Obsidian.png
Type=Application
Categories=Office;Utility;
StartupNotify=true
Terminal=false
Keywords=Notes;Markdown;Editor;Knowledge;

For another AppImage, change the Name, Exec, and Icon fields accordingly.

If the application provides an official icon, download and save it:

wget -O ~/.local/share/icons/Obsidian.png "https://upload.wikimedia.org/wikipedia/commons/6/6c/Obsidian-logo.png"

For another application, replace the URL and filename.

Step 5: Update the Desktop Database

To register the new application, run:

update-desktop-database ~/.local/share/applications/

Now, you should be able to find the application in Rofi or dmenu.

Step 6: Launch the AppImage from Rofi (drun mode)

Press your Rofi shortcut key (usually Mod1 + D or Alt + D) and search for the application name. It should now appear in the list!

Alternatively, you can use dmenu:

dmenu_run

Type the application name and press enter to launch it.

Installing Other AppImages

If you want to install a different AppImage, follow the same steps:

Download the AppImage and place it in ~/.local/share/AppImage.
Make it executable using chmod +x.
Create a .desktop file in ~/.local/share/applications/.
Download an icon if available and set the correct path.
Update the desktop database.
Launch it using Rofi or dmenu.

Just replace filenames and URLs accordingly.

Conclusion

Manually installing and setting up AppImages on Arch Linux ensures they integrate seamlessly into your application launchers like Rofi and dmenu. With these steps, you can keep your system clean and portable while still accessing the latest software. 🚀

rnr: The Tool That Speaks Every Project run scripts

Sujit Kumar — Sat, 28 Sep 2024 16:29:01 +0000

Hey there, JavaScript and TypeScript developers! 👋 Are you tired of juggling different commands to start your various JS projects? Well, I've got some exciting news for you! I've created a tool called rnr (pronounced "runner") that makes running any JavaScript or TypeScript project super easy.

What's rnr and Why Did I Make It?

Imagine you're working on several JavaScript projects - maybe a React app, a Node.js server, and a Vue.js website. Each one needs a different command to start. It's like having a bunch of different remote controls, one for each device. Confusing, right?

That's why I made rnr. It's like a universal remote for your JS and TS projects. You just type rnr, and it figures out how to start your project, no matter what framework or library you're using!

Cool Things rnr Can Do

It's Smart: rnr looks at your project and knows if it's React, Vue, Express, or any other popular JS framework.
Works with Lots of JS Projects: Whether you're using Next.js, Express, React, Vue, or plain JavaScript, rnr knows how to handle them all.
Picks the Best Package Manager: rnr automatically chooses between npm, Yarn, pnpm, or Bun - whichever is best for your project.
One Command Does It All: Want to run in dev mode? Build your project? Start it in production mode? rnr can do all of that with just a tiny change to the command.
Easy to Set Up: rnr sets itself up, but you can tweak things if you want to customize how it works with your project.

rnr Modes: Different Ways to Run Your JS Project

rnr is super flexible. It has different modes to help you work on your JavaScript project in different ways:

Dev Mode: This is for when you're coding and want to see your changes right away. It's like having a live preview of your work.
Use it like this: rnr dev or just rnr
Build Mode: When you're ready to get your project ready for deployment, use this mode. It's like packaging up your app for shipping.
Use it like this: rnr build
Production Mode: This is for running your app in a production environment. It's optimized for performance, not for development.
Use it like this: rnr prod

And we're not stopping there! We're working on adding even more modes to make your JavaScript development life easier.

How to Get Started with rnr

Getting rnr is super easy. Just type this in your command line:
Explore here

npm i -g @sujit-shrc/rnr

Then, go to any of your JavaScript or TypeScript project folders and type:

rnr

That's it! rnr will start your project for you.

Why I Made rnr

As a JavaScript developer, I was tired of switching between npm run dev, yarn start, pnpm run serve, and so on for different projects. I thought, "There has to be a better way!" That's how rnr was born - to make running JS projects simple and consistent.
Go to npmjs

Why You'll Love rnr

Saves Time: No more looking up how to start each JS project.
Works with All JS Frameworks: Use the same command for your React, Vue, Angular, or Node.js projects.
Easy Mode Switching: Switch between development, production, and build modes effortlessly.
Keeps Getting Better: We're always adding support for more JS tools and frameworks.

What's Next for rnr?

We're working on making rnr even better for JavaScript and TypeScript developers! We're looking at adding support for more frameworks, improving how it detects project types, and maybe even adding some cool features for testing and debugging. Stay tuned!

Try rnr Today!

Want to make running your JavaScript and TypeScript projects super easy? Give rnr a try:

npm i -g @sujit-shrc/rnr

Check out our GitHub repo to learn more, report any issues, or contribute to making rnr even better for the JS community.

Let's make JavaScript development easier and more fun together!

Happy coding, JS enthusiasts! 😊

P.S. We'd love to hear what you think about rnr! Did you try it with your JavaScript projects? Do you have ideas to make it better for TypeScript users? Let us know in the comments or on GitHub. Your feedback helps us make rnr awesome for all JS developers!

My Go-To File Transfer Tools in Linux: A Terminal Lover's Guide

Sujit Kumar — Wed, 28 Aug 2024 15:54:25 +0000

Hey fellow Linux enthusiasts! Today, I want to share my favorite command-line tools for downloading and sharing files. As someone who practically lives in the terminal, I've found these tools to be indispensable in my daily workflow.

Downloading Files: wget and curl

When it comes to grabbing files from the web, two tools always come to mind: wget and curl.

wget: My Reliable Downloader

I love wget for its simplicity and power. Here's how I typically use it:

# Basic download
wget https://example.com/file.zip

# Resuming an interrupted download
wget -c https://example.com/large-file.iso

# Downloading with a custom filename
wget -O my-file.zip https://example.com/file-with-long-name.zip

Pro tip: If you're downloading a file on a flaky connection, try wget --tries=0 --retry-connrefused. It'll keep trying until the download succeeds.

curl: More Than Just Downloads

While wget is great, curl is my Swiss Army knife for web interactions:

# Basic file download
curl -O https://example.com/file.txt

# Following redirects (super handy!)
curl -L -O https://example.com/redirected-file.txt

# Downloading with authentication
curl -u username:password -O https://example.com/secure-file.zip

I often use curl when I need to inspect headers or make specific HTTP requests alongside downloads.

Sharing Files: scp and sftp

When it comes to moving files between machines, security is key. That's why I stick with scp and sftp.

scp: Quick and Secure File Transfers

scp is my go-to for quick file transfers:

# Copying a local file to a remote system
scp /path/to/local/file user@remote:/path/to/destination

# Copying from remote to local
scp user@remote:/path/to/remote/file /path/to/local/destination

# Transferring entire directories
scp -r /local/directory user@remote:/remote/path

I find scp particularly useful for its simplicity – it works just like cp, but over SSH.

sftp: When You Need More Interaction

For more complex file management tasks, I turn to sftp:

# Connect to remote system
sftp user@remote

# Once connected:
get remotefile.txt   # Download file
put localfile.txt    # Upload file
ls                   # List remote files
lls                  # List local files

I love sftp for its interactive nature. It's perfect when I need to browse remote directories or perform multiple file operations.

Bonus Tip: Downloading from a List of URLs

Sometimes, I find myself needing to download multiple files from a list of URLs. Here's a neat trick I use with both wget and curl to handle this scenario:

Using wget with a file list

If you have a file (let's call it urls.txt) containing URLs, each on a separate line, you can use wget like this:

wget -i urls.txt

This command tells wget to read the URLs from the file and download each one. It's super handy when you're dealing with a bunch of files!

Using curl with a file list

Curl can also handle this task, though it requires a bit more setup:

xargs -n 1 curl -O < urls.txt

This command uses xargs to feed each line from urls.txt to curl, which then downloads the file.

My personal preference

Honestly, I tend to lean towards wget for this task. It's simpler and doesn't require additional commands. Plus, wget has some cool features for this scenario:

# Download files in the background
wget -b -i urls.txt

# Limit the download speed (useful to avoid network saturation)
wget --limit-rate=500k -i urls.txt

# Continue partially downloaded files
wget -c -i urls.txt

These options make wget incredibly flexible when working with file lists.

Wrapping Up

These four tools – wget, curl, scp, and sftp – cover almost all of my file transfer needs in Linux. They're powerful, secure, and incredibly versatile. Plus, using them from the terminal just feels so much more efficient than clicking around in a GUI.

What are your favorite file transfer tools in Linux? Do you use these, or do you have some hidden gems I should know about? Drop a comment below – I'm always eager to learn new tricks!

Until next time, happy file transferring!

Mastering Conventional Git Commit Messages for Better Collaboration

Sujit Kumar — Mon, 22 Jul 2024 05:02:08 +0000

My Adventure with Conventional Commits: A Simple Guide

Hey there! I'm excited to share my journey with Conventional Commits. When I first started coding, my commit messages were a mess. But then I discovered this cool way of writing commits that changed everything for me. Let me tell you all about it!

What Are Conventional Commits?

Conventional Commits are just a fancy way of saying "a set of rules for writing better commit messages". It's like having a template for your commits that makes them easier to understand and use.

The Basic Idea

Here's the simple structure:

type(optional scope): short description

longer explanation if you need it [option body part]

any extra notes [optional footer part]

Don't worry, I'll break this down for you!

When I started, I kept forgetting which types to use. So I made a little cheat sheet. Here are the main ones I use:
Certainly! I'll explain all the commit message types, provide examples of good and bad commit messages, and then offer some improved versions. Here's a comprehensive guide:

Understanding Commit Message Types

feat: A new feature for the user or a significant addition to the application.
fix: A bug fix.
docs: Changes to documentation.
style: Changes that don't affect the code's meaning (white-space, formatting, missing semi-colons, etc.).
refactor: Code changes that neither fix a bug nor add a feature.
perf: Code changes that improve performance.
test: Adding or modifying tests.
build: Changes that affect the build system or external dependencies.
ci: Changes to CI configuration files and scripts.
chore: Other changes that don't modify src or test files.

Examples of Good vs Bad Commit Messages

1. feat (Feature)

Good:

feat(auth): implement two-factor authentication

Bad:

added new stuff

Better:

feat(auth): add Google Authenticator integration for 2FA

- Implement QR code generation for easy setup
- Add verification step to login process
- Include user settings to enable/disable 2FA

2. fix (Bug Fix)

Good:

fix(checkout): resolve total calculation error in cart

Bad:

fixed bug

Better:

fix(checkout): correct tax calculation for international orders

- Update tax rate retrieval to consider user's country
- Add unit tests for various tax scenarios
- Refactor tax calculation into separate utility function

3. docs (Documentation)

Good:

docs: update API endpoints in README

Bad:

changed readme

Better:

docs(api): revise and expand API documentation

- Add examples for all endpoints
- Include rate limiting information
- Update authentication section with new token format

4. style (Formatting)

Good:

style(global): apply consistent indentation to all files

Bad:

prettier

Better:

style: enforce consistent code style across project

- Apply Prettier with custom ruleset
- Adjust ESLint config to align with new style guide
- Update CI to fail on style violations

5. refactor

Good:

refactor(database): optimize user query for better performance

Bad:

cleaned up code

Better:

refactor(user-service): improve efficiency of user data retrieval

- Replace multiple database calls with single aggregated query
- Implement caching layer for frequently accessed user data
- Update related services to use new optimized methods

6. perf (Performance)

Good:

perf(images): implement lazy loading for product images

Bad:

made site faster

Better:

perf(front-end): optimize initial page load time

- Implement code splitting for React components
- Set up lazy loading for below-the-fold content
- Minimize and compress all static assets

7. test

Good:

test(api): add unit tests for user registration process

Bad:

added tests

Better:

test(auth): expand test coverage for authentication module

- Add unit tests for password reset functionality
- Implement integration tests for OAuth flow
- Set up mock server for third-party auth provider testing

8. build

Good:

build(deps): upgrade to React 18

Bad:

updated packages

Better:

build: migrate from Webpack to Vite for faster builds

- Configure Vite for development and production environments
- Update npm scripts for new build process
- Adjust CI pipeline to accommodate Vite builds

9. ci (Continuous Integration)

Good:

ci(travis): add automatic deployment to staging environment

Bad:

updated ci

Better:

ci: implement comprehensive CI/CD pipeline with GitHub Actions

- Set up automated testing for PRs
- Configure staging deployment on merge to develop branch
- Implement production deployment process for tagged releases

10. chore

Good:

chore: update .gitignore to exclude .env files

Bad:

misc changes

Better:

chore(project): streamline development setup process

- Create detailed CONTRIBUTING.md with setup instructions
- Add .env.example file with required environment variables
- Update package.json with helpful npm scripts for common tasks

Commit message with footer

feat(user-profile): add ability to upload profile picture

- Implement image upload functionality
- Add image cropping and resizing options
- Create new API endpoint for image upload

BREAKING CHANGE: This update requires a new 'images' table in the database.
Reviewed-by: Sujit
See-also: #123, #456
Closes: #789

Tips I Learned the Hard Way

Be clear about what you did. Future you will thank present you!
Keep the first line short - aim for 50 characters or less.
Use simple language. Pretend you're telling a friend what you did.
If you're fixing a bug or implementing a feature, mention the issue number if you have one.

Why I Love Conventional Commits

It's easier to find things in the project history.
It helps me think clearly about what I'm committing.
My team can understand my changes without asking me a million questions.
We can automatically generate changelogs and version numbers.

Oops! I Made a Mistake

Don't panic! We all make mistakes. If you used the wrong type and haven't pushed your commit yet, you can fix it:

Use git commit --amend to change your last commit message.
If it's an older commit, use git rebase -i or git rebase -i HEAD~n (replace n with the number of commits to go back), then change pick to reword for the commit you want to fix.

If you've already pushed, it's usually best to just make a new commit with the correct message. Learn and move on!

Wrapping Up

Adopting Conventional Commits was a game-changer for me. It made my commits clearer, helped my team work better together, and even made me think more carefully about my code changes.

Start small, be consistent, and don't worry if you make mistakes at first. Before you know it, you'll be a Conventional Commit pro!

Have you tried Conventional Commits? I'd love to hear about your experiences. Drop a comment below and let's chat!

Happy coding, everyone! 😊

The FastAPI Deployment Cookbook: Recipe for deploying FastAPI app with Docker and DigitalOcean"

Sujit Kumar — Mon, 01 Jul 2024 15:17:43 +0000

From Local to Live: My Journey Deploying FastAPI with Docker on DigitalOcean

Hey there, fellow developers! Today, I want to share my recent experience deploying a FastAPI application using Docker on a DigitalOcean droplet. It was quite a learning curve, but I've broken it down into manageable steps that I hope will help you avoid some of the pitfalls I encountered. Let's dive in!

What You'll Need Before We Start

A DigitalOcean account (I'm using a basic droplet with Docker pre-installed)
Some familiarity with Docker and FastAPI (but don't worry if you're new, we'll go through this together!)
SSH access to your droplet

Step 1: Crafting Your FastAPI App

First things first, let's create a simple FastAPI app. Here's the bare-bones version I started with:

main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello from FastAPI"}

Pretty straightforward, right? This just returns a JSON response when you hit the root endpoint.

Step 2: Don't Forget Your Dependencies!

I learned this the hard way: always keep your requirements.txt updated. Here's what mine looks like:

requirements.txt

fastapi
uvicorn

Pro tip: Use pip freeze > requirements.txt to automatically generate this file from your current environment.

Step 3: Dockerizing Your App

Now, let's containerize our app. Here's the Dockerfile I ended up with after some tweaking:

Dockerfile

FROM python:3.11-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]  #or second command will work only when your main.py file contains your initial fastapi setup
# CMD ["fastpi", "run", "--host", "0.0.0.0", "--port", "8000"]

Step 4: Building and Running Your Docker Container

Here's where the magic happens. SSH into your DigitalOcean droplet:

ssh user@your_droplet_ip

Note: You can build your docker image locally then push it on dockerhub and after that you can pull your app-image on your production server directly. But for now we are building our docker image on production sever
Once logged in, run these commands:

docker build -t fastapi-app .
docker run -d --name fastapi-app -p 8000:8000 fastapi-app

Quick tip: Add --restart unless-stopped to the docker run command to make your container restart automatically if it crashes or if your droplet reboots.

Step 5: Verifying Your Deployment

After deployment, you can check the status of your running FastAPI app:

docker ps

To view the logs of your FastAPI app:

docker logs fastapi-app

To view stats of docker container usage(memory, cpu usage) of each running container

docker stats

Step 6: Accessing Your Live Website

Your FastAPI app should now be accessible at http://your_droplet_ip:8000. Open this URL in your browser to see your live website!

Important Note: If your main file is named main.py and contains the FastAPI app instance named app, you can use the fastapi run command instead of the custom uvicorn setup. However, when using Docker, we typically stick with the uvicorn command for more control over the host and port settings.

Step 7: Setting Up Nginx as a Reverse Proxy (Optional)

Setting up Nginx as a reverse proxy can improve performance and security. Here's how to do it:

Install Nginx:

   sudo apt update
   sudo apt install nginx

Create a new config file:

   sudo nano /etc/nginx/sites-available/fastapi

Add this configuration:

   server {
       listen 80;
       server_name your_domain_or_ip;

       location / {
           proxy_pass http://localhost:8000;
           proxy_set_header Host $host;
           proxy_set_header X-Real-IP $remote_addr;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header X-Forwarded-Proto $scheme;
       }
   }

Enable the config and restart Nginx:

   sudo ln -s /etc/nginx/sites-available/fastapi /etc/nginx/sites-enabled/
   sudo systemctl restart nginx

If you set up Nginx, your app will be accessible at http://your_droplet_ip (without the port number).

Bonus Tips I Wish I'd Known Earlier

HTTPS is a must: I highly recommend setting up HTTPS using Let's Encrypt. It's free and easier than you might think!
Monitoring is key: I use Prometheus and Grafana to keep an eye on my app's performance. It's saved me more than once!
Automate your deployments: Look into CI/CD pipelines. I use GitHub Actions, and it's been a game-changer for my workflow.
Keep your images lean: Use multi-stage builds to keep your Docker images as small as possible. It'll save you time and resources in the long run.
Environment variables are your friends: Don't hardcode sensitive information. Use environment variables or Docker secrets instead.

Wrapping Up

Deploying FastAPI with Docker on DigitalOcean has been an exciting journey for me. It's opened up a whole new world of possibilities for my web development projects. I hope this guide helps you on your own deployment adventures!

Have you tried deploying FastAPI or any other Python web framework? I'd love to hear about your experiences in the comments. And if you found this guide helpful, don't forget to share it with your fellow devs!

Happy coding, and may your deployments always be smooth! 🚀

Goodbye IP Addresses, Say Hello to the Magic of Network Aliases

Sujit Kumar — Mon, 01 Jul 2024 14:26:57 +0000

Network Management Made Easy: My Go-To Alias Trick

Hey there, fellow tech enthusiasts! Today, I'm sharing my favorite hack for simplifying network management: using aliases instead of IP addresses. Trust me, this little trick has saved me countless headaches. Let's dive in!

Why Bother with Aliases?

Before we get to the how-to, let me tell you why this is so awesome:

Easy to remember: "printer" is way easier to recall than 192.168.1.101
Fewer typos: Less chance of mistyping a long IP address
Quicker commands: Type ssh user@webserver instead of ssh user@192.168.1.100
Consistency: Even if IP addresses change, your aliases stay the same

Setting Up Aliases on Linux/Mac

Open Terminal and type:

   sudo nano /etc/hosts

Add your aliases like this:

   192.168.1.1    router
   192.168.1.100  webserver
   192.168.1.101  staging-server
   192.168.1.102  printer

Save with Ctrl+X, then Y, then Enter.
Test it out:

   ping webserver

Pro tip: I like to add comments to my hosts file for future reference:

# Home Network Devices
192.168.1.1    router
192.168.1.100  webserver
192.168.1.101  staging-server
192.168.1.102  printer

Setting Up Aliases on Windows

Run Notepad as administrator (right-click, "Run as administrator")
Open C:\Windows\System32\drivers\etc\hosts
Add your aliases just like in the Linux example
Save and exit

Quick Tip: If you can't save the file, try moving it to your desktop, edit it there, then move it back.

Practical Uses

Now that you've set this up, here are some cool ways I use it:

Quick SSH:

   ssh username@webserver

Fast file transfers:

   scp myfile.txt username@staging-server:/path/to/destination/

Easy networking troubleshooting:

   traceroute printer

Hassle-free web development: In your browser, just type http://webserver instead of the IP

Bonus Tips

Use meaningful names: Choose aliases that make sense to you.
Keep it updated: Whenever you add a new device to your network, make it a habit to add an alias for it.
Backup your hosts file: I keep a copy of my hosts file in my cloud storage. It's a lifesaver when setting up a new machine.
Use it for remote servers too: I add aliases for my cloud servers as well. It's super handy when managing multiple environments.

Wrapping Up

This simple trick has genuinely made my day-to-day tech life so much smoother. Give it a shot, and I bet you'll wonder how you ever managed without it. Got any cool networking tricks of your own? Drop them in the comments – I'm always eager to learn more!

Remember, networking doesn't have to be a pain. With a little setup, you can make your digital life a whole lot easier. Happy networking, folks!

Decoding the Linux Command Line: 75 Indispensable Utilities Explained

Sujit Kumar — Fri, 14 Jun 2024 14:32:58 +0000

Top 75 Linux Commands Every Regular User Must Know

As a regular Linux user, mastering these essential commands can greatly enhance your productivity and efficiency. Let's dive into the top 75 Linux commands with practical examples.

ls (List)
- ls - List files and directories in the current directory.
- ls -a - List all files, including hidden ones.
- ls -l - List files with detailed information (permissions, owner, size, etc.).
- ls -h - List files with detailed information in human readable format.
pwd (Print Working Directory)
- pwd - Display the current working directory.
cd (Change Directory)
- cd /path/to/directory - Navigate to the specified directory.
- cd .. - Move up one directory level.
- cd ~ - Navigate to your home directory.
- cd - - Go back to the last directory.
mkdir (Make Directory)
- mkdir new_directory - Create a new directory.
- mkdir -p /path/to/nested/directories - Create nested directories.
touch (Create File)
- touch new_file.txt - Create a new, empty file.
mv (Move)
- mv file.txt /path/to/directory - Move a file to a different directory.
- mv old_name.txt new_name.txt - Rename a file.
cp (Copy)
- cp file.txt /path/to/directory - Copy a file to a different directory.
- cp -r directory1 /path/to/directory2 - Copy a directory and its contents.
rm (Remove)
- rm file.txt - Delete a file.
- rm -r directory - Delete a directory and its contents (use with caution!).
cat (Concatenate)
- cat file.txt - Display the contents of a file.
- cat file1.txt file2.txt > combined.txt - Combine two files into one.
echo (Print)
- echo "Hello, World!" - Print a string.
- echo $PATH - Print the value of an environment variable.
clear
- clear - Clear the terminal screen.
man (Manual)
- man ls - Display the manual page for the ls command.
uname (System Information)
- uname -a - Display detailed information about the system.
whoami (User Information)
- whoami - Print the current user's username.
head (Show Top Lines)
- head -n 10 file.txt - Display the first 10 lines of a file.
tail (Show Bottom Lines)
- tail -n 20 log.txt - Display the last 20 lines of a file.
diff (Compare Files)
- diff file1.txt file2.txt - Compare the contents of two files.
cmp (Compare Files)
- cmp file1.txt file2.txt - Check if two files are identical byte-by-byte.
comm (Compare Files)
- comm -13 file1.txt file2.txt - Show lines unique to each file and common lines.
sort (Sort)
- sort file.txt - Sort the lines of a file in alphabetical order.
- sort -n file.txt - Sort the lines of a file numerically.
tar (Archive)
- tar -czf archive.tar.gz directory - Create a compressed tar archive of a directory.
- tar -xzf archive.tar.gz - Extract files from a compressed tar archive.
grep (Search)
- grep "pattern" file.txt - Search for a pattern in a file.
- ps aux | grep process_name - Find processes containing a specific name.
ln (Create Link)
- ln -s /path/to/file link_name - Create a symbolic link to a file.
export (Set Environment Variables)
- export PATH=$PATH:/new/path - Add a new path to the PATH environment variable.
zip (Compress Files)
- zip archive.zip file1.txt file2.txt - Create a ZIP archive with multiple files.
unzip (Extract Files)
- unzip archive.zip - Extract files from a ZIP archive.
ssh (Secure Shell)
- ssh user@remote_host - Connect to a remote system via SSH.
service (Manage Services)
- service apache2 start - Start the Apache web server service.
- service mysql status - Check the status of the MySQL service.
ps (Process Status)
- ps aux - Display detailed information about running processes.
kill and killall (Terminate Processes)
- kill 1234 - Terminate a process with the specified PID (1234).
- killall process_name - Terminate all processes with a specific name.
df (Disk Usage)
- df -h - Display disk usage in a human-readable format.
mount (Mount File Systems)
- mount /dev/sdb1 /mnt/usb - Mount a USB drive to the /mnt/usb directory.
chmod (Change Permissions)
- chmod 755 file.sh - Grant read, write, and execute permissions to the owner, and read and execute permissions to group and others.
chown (Change Ownership)
- chown user:group file.txt - Change the owner and group of a file.
ifconfig (Network Configuration)
- ifconfig - Display information about network interfaces and IP addresses.
traceroute (Trace Network Route)
- traceroute example.com - Trace the network path to a remote host.
wget (Web Get)
- wget https://example.com/file.zip - Download a file from a web server.
ufw (Uncomplicated Firewall)
- ufw enable - Enable the firewall.
- ufw allow 22 - Allow incoming connections on port 22 (SSH).
iptables (Firewall)
- iptables -L - List current firewall rules.
- iptables -A INPUT -p tcp --dport 80 -j ACCEPT - Allow incoming TCP connections on port 80 (HTTP).
apt, pacman, yum, rpm (Package Managers)
- apt update && apt upgrade (Ubuntu/Debian) - Update package lists and upgrade installed packages.
- pacman -Syu (Arch Linux) - Synchronize package databases and upgrade installed packages.
- yum update (CentOS/RHEL) - Update installed packages.
- rpm -ivh package.rpm - Install an RPM package.
sudo (Escalate Privileges)
- sudo command - Run a command with superuser (root) privileges.
cal (Calendar)
- cal - Display the current month's calendar.
- cal 2024 - Display the entire year's calendar for 2024.
alias (Create Command Shortcuts)
- alias ll='ls -l' - Create an alias for the ls -l command.
dd (Data Duplicator)
- dd if=/dev/zero of=/path/to/file bs=1M count=1024 - Create a 1GB file filled with zeros.
- dd if=/path/to/iso of=/dev/sdx - Write an ISO image to a USB drive.
whereis (Locate Command)
- whereis ls - Find the binary, source, and manual page files for the ls command.
whatis (Command Description)
- whatis ls - Display a brief description of the ls command.
top (Process Monitor)
- top - Display real-time information about running processes and system resource usage.
useradd and usermod (User Management)
- useradd new_user - Create a new user account.
- usermod -aG sudo new_user - Add an existing user to the sudo group.
passwd (Change Password)
- passwd - Change the password for the current user.
- passwd user_name (as root) - Change the password for a specific user.
curl (Transfer Data)
- curl https://example.com - Fetch the contents of a URL.
- curl ifconfig.me - Display your public IP address.
ping (Test Network Connectivity)
- ping google.com - Test connectivity to a remote host.
- ping -c 2 google.com - Send 2 ping packets and stop.
netstat (Network Statistics)

netstat -tunlp - Display listening network ports and associated processes.

rsync (Remote Sync)
- rsync -avz /path/to/source /path/to/destination - Sync files between directories locally or remotely.
scp (Secure Copy)
- scp file.txt user@remote_host:/path/to/destination - Copy files between hosts on a network.
find (Find Files)
- find /path -name filename - Search for files in a directory hierarchy.
locate (Locate Files)
- locate filename - Find the location of a file quickly.
chmod (Change File Permissions)
- chmod 755 file.sh - Change the permission of a file or directory.
chown (Change File Owner)
- chown user:group file.txt - Change the owner and group of a file.
su (Switch User)
- su - - Switch to the root user.
- su - username - Switch to another user.
usermod (Modify User)
- usermod -aG groupname username - Add a user to a group.
groupadd (Add Group)
- groupadd groupname - Create a new group.
groups (List Groups)
- groups username - Display groups for a user.
last (Last Logins)
- last - Show a listing of last logged in users.
hostname (Show or Set Hostname)
- hostname - Show the system's hostname.
- hostname new_hostname - Set the system's hostname.
history (Command History)
- history - Display the command history.
- !n - Execute command number n from history.
crontab (Cron Jobs)
- crontab -e - Edit the cron jobs.
- crontab -l - List the cron jobs.
bg (Background Jobs)
- bg - Resume a suspended job in the background.
fg (Foreground Jobs)
- fg - Bring a background job to the foreground.
jobs (List Jobs)
- jobs - List all jobs.
at (Schedule Tasks)
- at 10:00 - Schedule a command to run at 10:00 AM.
- atq - List the pending jobs of users.
basename (File Name)
- basename /path/to/file - Display file name without the directory path.
dirname (Directory Name)
- dirname /path/to/file - Display the directory path of a file.
file (File Type)
- file filename - Determine the file type.
watch (Execute/Watch Command)
- watch -n 5 df -h - Execute a program periodically, showing output fullscreen.
shutdown (Shutdown System)
- shutdown -h now - Shutdown the system immediately.
- shutdown -r now - Reboot the system immediately.

With these 75 essential Linux commands under your belt, you'll be well-equipped to navigate the command line, manage files and processes, customize your system, and supercharge your productivity on the Linux operating system.
Happy Coding!!

Mastering Git: Tips and Tricks for Efficient Version Control

Sujit Kumar — Wed, 29 Nov 2023 15:33:04 +0000

Git, the powerhouse of version control systems, empowers developers to manage their codebase effectively. As you delve deeper into the Git universe, discovering hidden gems and mastering its features can significantly enhance your workflow. One such gem is the often overlooked, yet incredibly handy, autocorrect feature.

Autocorrecting Typos for Swift Command Execution

Have you ever found yourself typing git comit instead of git commit in the heat of coding? Fear not, for Git has a solution—autocorrect. By default, Git graciously suggests the most likely correct command when faced with a typo.

$ git comit -m "Some awesome work"
git: 'comit' is not a git command. See 'git --help'.

The most similar command is
  commit

Instant Autocorrect for the Impatient Developer

For those who can't wait to correct their mistakes, Git offers the immediate autocorrect mode. By setting the help.autocorrect configuration to immediate, Git will automatically run the first closely matched command without prompting.

$ git config --global help.autocorrect immediate
$ git comit -m "Some awesome work"
[main 25112f085] Some awesome work

The Cautious Approach: Autocorrect with Prompt

If the idea of immediate execution makes you a bit uneasy, Git provides a middle ground—prompt mode. This mode prompts you with a yes/no confirmation before executing the autocorrected command.

$ git config --global help.autocorrect prompt
$ git comit -m "More awesome work"
Run 'commit' instead [y/N]? y
[main 2183b892e] More awesome work

Introducing a Timeout: Autocorrect with a Safety Net

For those who want to add an extra layer of caution, Git allows you to set a timeout before automatically proceeding. This provides a short window for you to cancel the autocorrected command if needed.

$ git config --global help.autocorrect 20
$ git comit -m "Even more work" --allow-empty
Continuing in 2.0 seconds, assuming that you meant 'commit'.
[main b0be18f0d] Even more work

Additional Git Tips and Tricks

Now that we've explored the power of autocorrect, let's delve into more Git tips and tricks to supercharge your version control skills.

1. Interactive Staging

Git allows you to stage changes interactively, giving you fine-grained control over what goes into your commit. Use the following command to enter interactive staging:

$ git add -i

This opens an interactive menu, allowing you to choose which changes to stage, unstage, or even split into smaller changes.

2. Stash Uncommitted Changes

Got changes you're not ready to commit, but you need to switch branches? Stash them!

$ git stash save "Your stash message"

Later, you can reapply your changes:

$ git stash apply

3. Reflog: Your Safety Net

Ever made a change and then realized it was a mistake? The reflog is your safety net. It keeps a log of all reference updates, including branch switching and resets.

$ git reflog

You can then use the commit hash to reset your branch back to a previous state.

4. Aliases for Efficiency

Create aliases for your frequently used Git commands to save keystrokes. For example:

$ git config --global alias.co checkout
$ git config --global alias.br branch
$ git config --global alias.ci commit

Now you can use git co, git br, and git ci instead of the longer commands.

5. Git Hooks

Git hooks enable you to automate actions at different points in the Git workflow. For instance, you can use a pre-commit hook to run tests before committing.

Explore the .git/hooks directory in your repository to see the available hooks.

6. Git Bisect for Bug Hunting

When you encounter a bug and need to find the commit that introduced it, Git Bisect is your ally.

$ git bisect start
$ git bisect bad  # Current commit has the bug
$ git bisect good <commit>  # A known good commit
$ git bisect run <test_command>

Git will perform a binary search, helping you identify the commit responsible for the bug.

7. Search Through Commits

Looking for a specific change but can't remember which commit it's in? Use git log with the -S option to search for a specific string.

$ git log -S "your search term"

8. Git Worktree: Multiple Working Directories

Git worktree allows you to maintain multiple working directories from a single repository. This is handy when you need to work on different branches simultaneously.

$ git worktree add -b <new_branch> <path>

9. Rebase for a Clean History

Instead of merging branches, consider rebasing for a cleaner commit history.

$ git checkout feature_branch
$ git rebase main

This integrates changes from the main branch into your feature branch without creating a merge commit.

10. Git Archive: Export Without .git Directory

When you need to create a clean export of your project without the .git directory, use git archive.

$ git archive --format=zip --output=project.zip master

This creates a zip file of your project, excluding version control files.

Incorporate these tips and tricks into your Git workflow, and watch as your version control mastery reaches new heights. Happy coding!

Diving into Data: A Comprehensive Guide to Database Fundamentals

Sujit Kumar — Sat, 11 Nov 2023 13:57:34 +0000

01_Intro:

In this blog post, we will introduce you to the basics of databases, including what they are, different types of databases, and how they are used in the real world. We will also provide some technical examples

Understanding Data:

Data is the raw facts and figures, such as numbers, text, images, or any other pieces of information that can be stored and processed.

What is a Database?

A database is a structured collection of data that is organized and stored in a way that allows for efficient retrieval and manipulation. It acts as a centralized repository for managing and storing information.

Properties of a Database:

Data Integrity: This ensures that the data in the database is accurate and consistent. For example, if you have a table storing employee information, data integrity would prevent a situation where an employee is assigned to a non-existent department.
Security: Database systems implement security measures to control access to data. For instance, a user might have read-only access to a table containing recipes but can't modify the original recipes.
Concurrency Control: This property manages the simultaneous access to the database by multiple users to prevent conflicts. If two chefs try to modify the same recipe at the same time, concurrency control ensures that changes are made in a controlled manner.

Types of Databases:

1. Relational Database:

A relational database organizes data into tables with rows and columns. Tables are related based on common attributes, creating a structured and easily understandable format. Let's consider an example:

Table: Recipes
| RecipeID | RecipeName | Ingredients | Category |
|----------|----------------|------------------------------|-------------|
| 1 | Spaghetti Bolognese | Pasta, Tomatoes, Beef, Onion | Main Course |
| 2 | Chocolate Cake | Flour, Sugar, Cocoa | Dessert |

2. NoSQL Database:

A NoSQL database is more flexible, allowing for the storage of various data types. Consider a document-oriented NoSQL database:

Example Document: Customer

{
  "CustomerID": 1,
  "Name": "John Doe",
  "Orders": [
    {
      "OrderID": 101,
      "Product": "Laptop",
      "Quantity": 2
    },
    {
      "OrderID": 102,
      "Product": "Smartphone",
      "Quantity": 1
    }
  ]
}

3. Column Database:

In a column database, data is stored vertically rather than horizontally. This optimizes the retrieval of specific information. Consider a column-oriented table:

Table: Sales
| Product | Jan_Sales | Feb_Sales | Mar_Sales |
|-----------|-----------|-----------|-----------|
| Laptop | 100 | 120 | 90 |
| Smartphone| 50 | 60 | 45 |

4. Graph Database:

A graph database represents data as nodes and edges. It's ideal for scenarios where relationships are crucial. Consider a social network scenario:

Graph: Social Network

(John)-[:FRIENDS]->(Jane)
(Jane)-[:FOLLOWS]->(Bob)

5. Key-Value Database:

A key-value database stores data as pairs of keys and values. It's simple but powerful for quick data retrieval. Consider a configuration settings scenario:

Example: Configuration Settings

{
  "Theme": "Dark",
  "FontSize": 16,
  "Language": "English"
}

6. Relational Database:

In a relational database, tables are interconnected based on common keys. For instance:

Table: Employees
| EmployeeID | Name | DepartmentID |
|------------|------------|--------------|
| 1 | Alice | 101 |
| 2 | Bob | 102 |

DBMS (Database Management System):

A DBMS (Database Management System) is software that interacts with the database. It manages tasks like data entry, retrieval, and updates. Examples include MySQL, MariaDB, PostgreSQL, or MongoDB.

Keys:

In a relational database, keys are crucial for uniquely identifying records within a table. Let's consider an example with two tables: Students and Courses.

Table: Students
| StudentID | Name | Age |
|-----------|-----------|-----|
| 1 | Alice | 20 |
| 2 | Bob | 22 |
| 3 | Charlie | 21 |

Table: Courses
| CourseID | CourseName | Instructor |
|----------|------------------|-----------------|
| 101 | Mathematics 101 | Prof. Smith |
| 102 | Physics 201 | Prof. Johnson |

In the Students table, the StudentID serves as the primary key, ensuring each student has a unique identifier. In the Courses table, the CourseID serves as the primary key, offering a unique identifier for each course.

Now, let's introduce a third table, Enrollments, to represent the relationship between students and courses.

Table: Enrollments
| StudentID | CourseID |
|-----------|----------|
| 1 | 101 |
| 2 | 101 |
| 2 | 102 |
| 3 | 102 |

In this Enrollments table, StudentID and CourseID together form a composite primary key, establishing a link between students and the courses they are enrolled in.

Cardinality of Relationship:

The cardinality of a relationship defines how many instances of one entity are related to another. Let's consider the relationship between students and courses.

One-to-One (1:1) Relationship:

In a one-to-one relationship, each record in the first table is related to one and only one record in the second table, and vice versa. This is less common but can be illustrated with a hypothetical Advisor table.

Table: Advisor
| StudentID | AdvisorName |
|-----------|-------------|
| 1 | Prof. Brown |
| 2 | Prof. Green |
| 3 | Prof. White |

Here, each student has a unique advisor, and each advisor advises only one student.

One-to-Many (1:N) Relationship:

In a one-to-many relationship, each record in the first table can be related to multiple records in the second table, but each record in the second table is related to only one record in the first table. Let's apply this to our Students and Enrollments tables.

Each student in the Students table can be enrolled in multiple courses, but each course in the Courses table is typically associated with multiple students.

Many-to-Many (M:N) Relationship:

In a many-to-many relationship, each record in the first table can be related to multiple records in the second table, and vice versa. The Enrollments table we introduced earlier represents a many-to-many relationship. Multiple students can be enrolled in multiple courses.

Understanding keys and the cardinality of relationships is fundamental for designing a well-structured and efficient relational database. These concepts ensure data integrity and provide a foundation for building complex and interconnected systems.

Drawbacks of Databases:

Complexity: Managing a large recipe collection (database) requires careful organization and planning, especially as the number of recipes (data) grows.
Cost: Establishing and maintaining a robust database can incur costs for hardware, software, and personnel.
Scalability Issues: Just as a kitchen might struggle to handle a sudden increase in the number of guests, databases may face challenges in scaling up to handle a growing volume of data.

Understanding these concepts is like becoming a master chef in the world of information management. Each type of database has its unique flavor, and choosing the right one depends on the specific needs of your "culinary" project.

"Thanks for tuning in! Until next time, happy learning and stay curious!"

Mastering Git: A Beginner's Guide to Version Control

Sujit Kumar — Sun, 05 Nov 2023 14:04:19 +0000

Welcome to the world of Git, a powerful version control system that helps you manage and track changes in your projects. Whether you're a coding novice or a seasoned developer, understanding Git is crucial for efficient collaboration and project management.

Chapter 1: Getting Started (Basics)

1. Repository

Git is all about repositories - digital project folders. To create a new one, use:

git init

To grab an existing one from the web:

git clone <repository-url>

2. Clone

Clone is like making a copy of a project. Use it to snag a remote repository:

git clone https://github.com/example/repo.git

3. Commit

Think of commits as snapshots of your project. To save your changes:

git add <filename>
git commit -m "Your commit message here"

4. Push

Push is for sharing your local changes with others:

git push origin master

5. Pull

Pull is for grabbing changes others made:

git pull origin master

6. Branch

Branches let you work on different parts at the same time:

git branch <branch-name>
git checkout <branch-name>

7. Merge

Merge combines changes from one branch into another:

git checkout master
git merge <branch-name>

8. Remote

Remote is the centralized repository where everyone collaborates:

git remote add origin <repository-url>

9. Fetch

Fetch gets changes from the remote without merging:

git fetch origin

10. HEAD

HEAD points to the latest commit in your working branch:

git log

Chapter 2: Advanced Techniques

1. Rebasing

Rebasing helps tidy up your commit history:

git checkout feature-branch
git rebase master

2. Stash

Stash is for saving changes not ready to be committed:

git stash

3. Cherry-picking

Cherry-picking lets you apply specific commits:

git cherry-pick <commit-hash>

4. Submodules

Submodules include external projects in your repository:

git submodule add <repository-url> <path>

5. Hooks

Hooks are scripts that run at key Git points:

Create pre-commit in .git/hooks/ with your script.

6. Gitignore

.gitignore excludes files from version control:

touch .gitignore

Edit to specify files to ignore.

7. Reflog

Reflog logs all changes to your repository:

git reflog

8. Bisect

Bisect helps find when a bug was introduced:

git bisect start
git bisect bad
git bisect good <commit-hash>

9. Tagging

Tags mark specific points in history:

git tag -a v1.0 -m "Version 1.0"

10. Interactive Rebase

Interactive rebase lets you modify commits:

git rebase -i HEAD~3

Mastering these basics and advanced Git concepts will empower you to efficiently manage your projects and collaborate seamlessly. Feel free to reach out if you want more details or explanations on any concept. Happy coding!

Docker: A Practical Guide with Arch Linux Setup: Part-1

Sujit Kumar — Thu, 26 Oct 2023 13:41:07 +0000

Docker Intro:

Docker has revolutionized the way we develop, deploy, and run applications. It provides a lightweight and efficient solution for packaging, distributing, and running software in isolated environments called containers. This blog post aims to guide you through the basics of Docker, including its setup on an Arch-based Linux system.

Docker Basics

Installation

To install Docker on Arch Linux, you can use the following commands:

sudo pacman -S docker
sudo systemctl start docker
sudo systemctl enable docker

This will install Docker and start the Docker daemon.

Adding User to Docker group

To add the user to the docker group, use the following command:

sudo usermod -aG docker $USER

This will add the user to the docker group without requiring sudo privileges.
Note: It requires to restart your device.

Running a Container

Let's start with a simple example. To run an Ubuntu container interactively, use:

docker run -it ubuntu

Find Images in Docker Hub

docker search jenkins

Download Docker Image from Docker Hub to Local

docker pull jenkins

Delete Local image

docker rmi image_name

This command pulls the Ubuntu image from the Docker Hub and starts an interactive shell within the container.

Managing Containers

Start/Stop a Container:

docker start container_name
docker stop container_name

List Containers:

docker ps -a

Go Inside Docker Container:

docker attach container_name

Execute a Command in a Running Container:

docker exec container_name command

Attach to a Running Container:

docker exec -it container_name bash

Remove a Container:

docker rm container_name

Inspect Container Details:

docker inspect container_name

Diff Containers

docker diff container_name

Commit changes into container and create updated image

docker commit container_name new_image_name

Listing Images

docker images

Dockerization with Dockerfile

A Dockerfile is a script that contains a set of instructions for building a Docker image. Here's a basic example for a Node.js application:

FROM ubuntu

RUN apt-get update && \
    apt-get install -y curl && \
    curl -sL https://deb.nodesource.com/setup_14.x | bash && \
    apt-get install -y nodejs

WORKDIR /app

COPY package.json package-lock.json ./

RUN npm install

COPY . .

CMD ["node", "main.js"]

To build the image, navigate to the directory containing the Dockerfile and run:

docker build -t your_image_name .

Container Networking

To expose a port from the container to the host system, use the -p flag. For example:

docker run -it -p 1025:1025 your_image_name

This maps port 1025 on the host to port 1025 on the container.

Conclusion

Docker simplifies the process of packaging, distributing, and running applications. In this guide, we covered basic Docker commands, the creation of Dockerfiles, and container networking. This should serve as a solid foundation for further exploration into the world of containerization.
Happy Dockering!

Mermaid: A powerful and flexible tool for creating diagrams

Sujit Kumar — Wed, 25 Oct 2023 05:44:53 +0000

What is Mermaid?

Mermaid is a lightweight, text-based, open-source diagram and flowchart description language. It is used to create diagrams of all kinds, including flowcharts, sequence diagrams, gantt charts, and state diagrams. Mermaid diagrams are created using a simple text format, which makes them easy to read and write.

Why use Mermaid?

There are many reasons to use Mermaid, including:

Simplicity: Mermaid is very easy to learn and use. Diagrams can be created using a simple text format, which makes them easy to read and write.
Flexibility: Mermaid can be used to create a wide variety of diagrams, including flowcharts, sequence diagrams, gantt charts, and state diagrams.
Power: Mermaid is a powerful tool for creating complex diagrams. It supports a wide range of features, such as subgraphs, loops, and conditional statements.
Community support: Mermaid has a large and active community of users who are always willing to help.

How to use Mermaid

To use Mermaid, you need to install the Mermaid renderer. There are renderers available for a variety of platforms, including web, desktop, and mobile devices.

Once you have installed the Mermaid renderer, you can start creating diagrams. To create a diagram, simply write the Mermaid code in a text file and save it with a .mmd extension. Then, open the file in the Mermaid renderer to view the diagram.

Mermaid examples

Here are some examples of Mermaid diagrams:

gitGraph
    commit
    commit
    branch develop
    checkout develop
    commit
    commit
    checkout main
    merge develop
    commit
    commit

pie title Pets adopted by volunteers
    "Dogs" : 386
    "Cats" : 85
    "Rats" : 15

gantt
    title A Gantt Diagram
    dateFormat  YYYY-MM-DD
    section Section
    A task           :a1, 2014-01-01, 30d
    Another task     :after a1  , 20d
    section Another
    Task in sec      :2014-01-12  , 12d
    another task      : 24d

This code creates a gantt chart that shows the development, testing, and deployment phases of a project.

Step-by-step guide to creating a Mermaid diagram

Install the Mermaid renderer.
Create a new text file and save it with a .mmd extension.
Write the Mermaid code in the text file.
Open the file in the Mermaid renderer to view the diagram.

Tips for creating Mermaid diagrams

Use meaningful names for your nodes and connectors.
Use clear and concise labels for your arrows.
Use consistent formatting throughout your diagram.
Use subgraphs to organize your diagram and make it easier to read.
Use loops and conditional statements to create complex diagrams.
Test your Mermaid code thoroughly before using it in production.

Conclusion

Mermaid is a powerful and flexible tool for creating diagrams of all kinds. It is easy to learn and use, and it has a large and active community of users. If you need to create diagrams, I encourage you to try Mermaid.

DEV Community: Sujit Kumar

Install AppImages on Arch Based Linux

How to Install and Use AppImages on Arch Linux

Step 1: Create a Directory for AppImages

Step 2: Download the AppImage

Step 3: Make the AppImage Executable

Step 4: Create a .desktop File

Step 5: Update the Desktop Database

Step 6: Launch the AppImage from Rofi (drun mode)

Installing Other AppImages

Conclusion

rnr: The Tool That Speaks Every Project run scripts

What's rnr and Why Did I Make It?

Cool Things rnr Can Do

rnr Modes: Different Ways to Run Your JS Project

How to Get Started with rnr

Why I Made rnr

Why You'll Love rnr

What's Next for rnr?

Try rnr Today!

My Go-To File Transfer Tools in Linux: A Terminal Lover's Guide

Downloading Files: wget and curl

wget: My Reliable Downloader

curl: More Than Just Downloads

Sharing Files: scp and sftp

scp: Quick and Secure File Transfers

sftp: When You Need More Interaction

Bonus Tip: Downloading from a List of URLs

Using wget with a file list

Using curl with a file list

My personal preference

Wrapping Up

Mastering Conventional Git Commit Messages for Better Collaboration

My Adventure with Conventional Commits: A Simple Guide

What Are Conventional Commits?

The Basic Idea

Understanding Commit Message Types

Examples of Good vs Bad Commit Messages

1. feat (Feature)

2. fix (Bug Fix)

3. docs (Documentation)

4. style (Formatting)

5. refactor

6. perf (Performance)

7. test

8. build

9. ci (Continuous Integration)

10. chore

Commit message with footer

Tips I Learned the Hard Way

Why I Love Conventional Commits

Oops! I Made a Mistake

Wrapping Up

The FastAPI Deployment Cookbook: Recipe for deploying FastAPI app with Docker and DigitalOcean"

From Local to Live: My Journey Deploying FastAPI with Docker on DigitalOcean

What You'll Need Before We Start

Step 1: Crafting Your FastAPI App

Step 2: Don't Forget Your Dependencies!

Step 3: Dockerizing Your App

Step 4: Building and Running Your Docker Container

Step 5: Verifying Your Deployment

Step 6: Accessing Your Live Website

Step 7: Setting Up Nginx as a Reverse Proxy (Optional)

Bonus Tips I Wish I'd Known Earlier

Wrapping Up

Goodbye IP Addresses, Say Hello to the Magic of Network Aliases

Network Management Made Easy: My Go-To Alias Trick

Why Bother with Aliases?

Setting Up Aliases on Linux/Mac

Setting Up Aliases on Windows

Practical Uses

Bonus Tips

Wrapping Up

Decoding the Linux Command Line: 75 Indispensable Utilities Explained

Top 75 Linux Commands Every Regular User Must Know

netstat (Network Statistics)

Mastering Git: Tips and Tricks for Efficient Version Control

Autocorrecting Typos for Swift Command Execution

Instant Autocorrect for the Impatient Developer

The Cautious Approach: Autocorrect with Prompt