DEV Community: dunkbing

A Minimal Note-Taking System with Vim, fzf, and Git

dunkbing — Sun, 14 Dec 2025 05:47:26 +0000

I wanted to share a simple note-taking workflow that's fast, works offline, and doesn't lock me into any platform. Here's a ~80 line bash script.

The Setup

Notes live in ~/notes as plain markdown files. That's it. No database, no app, no subscription.

Daily Notes

note              # opens ~/notes/2024-12-14.md
note ideas        # opens ~/notes/ideas.md
note work/standup # opens ~/notes/work/standup.md

The script creates parent directories automatically, so organizing by project or topic is effortless.

Finding Things

note -l           # list all notes, sorted by recent
note -s "keyword" # search content across all notes
note -t           # find all unchecked todos

All powered by fzf with preview. I can fuzzy-find through hundreds of notes instantly and jump to the exact line.

Syncing

note sync           # sync with git

First run initializes the repo and asks for a remote URL. After that, it pulls, commits changes with a timestamp, and pushes. Simple backup and multi-device sync.

Why This Works

Speed: vim opens instantly. no electron, no loading screens (or you can choose whatever editor you want).
Portable: plain text works everywhere, forever.
Searchable: grep + fzf.
Git history is free time travel.
No vendor lock-in: your notes are just files.

Using rclone and launchd to sync data to Google Drive on MacOS

dunkbing — Thu, 31 Oct 2024 14:39:41 +0000

Rclone is an open-source tool that we can copy our files or store on various cloud storage providers.

In this post, I'll use Rclone to sync data on MacOS with rclone + launchd (Mac daemons manager). You may ask why not just use built-in cloud sync? It's because I've been using Google Drive for a long time to back up my data and photos, and the Google Drive desktop app lacks flexibility in file exclusion.

Installation

I'm on Mac, so I'll use brew:

brew install rclone

To use Rclone, you need to configure it first, granting it access to the cloud service of your choice. These are the configuration process:

Open your terminal and run the following command to initiate the configuration setup:
```
rclone config
```
The configuration will prompt you to create a new remote connection. Choose option n for a new remote.

Next, you'll be prompted to name your remote connection. Give it a descriptive name, such as "Google Drive" or any name you prefer.
Select the number corresponding to the cloud storage provider you want to use. It's 18 for my case. (You can refer to the official RClone documentation for specific details on each provider.)

Leave the client ID and secret empty when prompted, and choose y to allow RClone to use the Google Drive API without these credentials.
The browser will automatically open and authenticate RClone with the remote.

Confirm your settings and the remote connection should be successfully configured.

Now, you have set up rclone to access your cloud storage. You can repeat these steps if you want to configure additional remotes for different cloud providers.

Syncing Data with rclone and Launchd

Now, let's move on to syncing data using RClone and scheduling it with Launchd:

Create a file named 'exclude-file.txt' to specify the files that you want to ignore from syncing. Mine looks like this.

Create a simple bash script to sync your data. Let's call it sync.sh:

#!/bin/bash

rclone sync --config ~/path/to/secure/location/rclone.conf /path/to/local/folder remote:destination/folder
rclone bisync --progress --exclude-from ~/.config/rclone/exclude-file.txt --resync --verbose /path/to/local/folder remote:destination/folder

Replace /path/to/local/folder with the path to the local folder you want to sync and remote:destination/folder with the remote destination on your cloud storage.

Make the script executable:
```
chmod +x sync.sh
```

Now, let's schedule the sync using Launchd. Create a new Launchd plist file, for example, com.example.rclone-sync.plist. Use a text editor to add the following content:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.example.rclone-sync</string>
    <key>Program</key>
    <string>/path/to/your/sync.sh</string>
    <key>RunAtLoad</key>
    <true/>
    <key>StartInterval</key>
    <integer>3600</integer>
</dict>
</plist>

Replace /path/to/your/sync.sh with the actual path to your sync.sh script.

Move the Launchd plist file to the appropriate directory:

mv com.example.rclone-sync.plist ~/Library/LaunchAgents/

Load the Launchd job:

launchctl load ~/Library/LaunchAgents/com.example.rclone-sync.plist

Now, your data will be automatically synced at the specified intervals using RClone and Launchd.

Create a simple web app with Deno's Fresh

dunkbing — Sat, 11 Nov 2023 09:54:06 +0000

Hi everyone! In this post, I'll guide you through creating a simple website using the Fresh framework and explore its various features.

Fresh is a full-stack JavaScript framework built on Deno. It's easy to set up and comes with cool features like quick rendering, no build step, built-in Typescript support, and island architecture (partial hydration).

What Am I Building?

I'm creating a straightforward speech-to-text web app using the Google Translate API. Check out the live demo app here. You can find the complete code for this tutorial in my GitHub repository.

Pre-requisites

Deno 1.3x
Familiarity with React and TypeScript

Creating a New Fresh App

Run the following commands to generate a new Fresh application:



deno run -A -r https://fresh.deno.dev text2audio
cd text2audio
deno task start

Visit localhost:8080 to explore your new Fresh app.

The project you create will include three main folders:

routes: Handles routing, similar to frameworks like Next.js. Each file corresponds to a route or pattern, and each folder represents a sub-route. Routes can have handlers to manage the verb and define actions like rendering or returning a response.
static: Stores static assets resolved using "/" in HTML templates and CSS files. Caching can be managed using assets.
islands: Contains interactive islands in your project. Each file's name corresponds to the defined island. The code within this folder can run on both the client and server.

Writing the Frontend and the API

Let's implement a Text Form and an API endpoint:

1) Text Form: Utilizes a POST form to submit to the /audio API to generate audio. Check out the code here.

2) API: Creates an API endpoint /api/audio with a POST request to generate audio from text. View the code here.

Additionally, I use DenoKV to store the total generated audio, which looks like this:



   async function increaseTotalAudio(num: number) {
     try {
       const voicesEntry = await kv.get(voicesEntryKey);
       const currentTotal = voicesEntry.value;
       await kv.set(voicesEntryKey, currentTotal + num);
     } catch (error) {
       console.error("increaseTotalAudio error", error);
     }
   }

For storing and serving audio files, I use Cloudflare R2, an S3-compatible storage service.

Deployments

The site is deployed with Deno Deploy, linking your Git repository to a Deno project on Deploy.

Alternatively, you can use Docker with the provided Dockerfile.

Performance

Fresh excels at boosting performance, as verified through PageSpeed Insights, generating a comprehensive report with all tested metrics.

Conclusion

Fresh is an interesting framework, targeting monolithic applications, especially those combining frontend and backend with robust SSR. Despite some limitations, Fresh shows promise for a bright future. I hope you find this post helpful!

Managing My Resume with Git: A Version Control Approach

dunkbing — Sun, 05 Nov 2023 11:39:44 +0000

In today's dynamic job market, maintaining an up-to-date and organized resume is crucial. However, it can be a challenging task without the right tools. In this post, I'll share with you how I manage my resume with Git, Github Actions, Makefile, and branching strategies.

Why Use Git for Your Resume?

1. Version Control: Git allows you to maintain different versions of your resume over time. This means you can keep a history of changes and easily switch between different versions, such as a general resume, one tailored for a specific job application, and more.

2. Collaboration: If you're working with others on a project or sharing your resume for feedback, Git makes collaboration a breeze. You can collaborate with others and merge changes seamlessly.

3. Backup and Safety: Git not only tracks changes but also serves as a backup system. Your resume is stored securely, and you can retrieve previous versions if needed.

4. Streamlined Workflow: Git simplifies the process of creating, editing, and formatting your resume. You can use plain text files (Markdown, for instance) and generate different formats (PDF, DOCX) when needed.

Setting Up Git for Resume Management

1. Create a Git Repository: Start by creating a Git repository for your resume. This can be done with a simple git init command.

2. Resume File: Save your resume in a text format (Markdown is a popular choice). This makes it easy to track changes and keep it under version control.

3. Versioning: Each time you make an update, commit the changes with a descriptive message. For example: "Updated skills section" or "Added new project experience."

4. Branches: Consider using branches to manage different versions of your resume. Create branches for specific job applications, skills variations, or different styles.

Makefile for Resume Management

A Makefile can simplify the process of converting your Markdown resume to different formats (PDF, DOCX) using Pandoc. Here's my sample Makefile:



# Convert Markdown (resume.md) to DOCX and PDF



RESUME = resume.md

OUTPUT_DIR = output

all: docx pdf

docx:

    @mkdir -p $(OUTPUT_DIR)

    pandoc $(RESUME) -o $(OUTPUT_DIR)/resume.docx

pdf:

    @mkdir -p $(OUTPUT_DIR)

    pandoc $(RESUME) -o $(OUTPUT_DIR)/resume.pdf

clean:

    rm -rf $(OUTPUT_DIR)

.PHONY: all docx pdf clean

Benefits of Using Markdown

Markdown is a lightweight markup language that is easy to read and write. It's an excellent choice for managing your resume with Git. Here's why:

Simplicity: Markdown is a plain text format that's easy to edit and understand.
Portability: Markdown files can be converted to various formats (PDF, DOCX, HTML) using tools like Pandoc.
Consistency: Markdown ensures your resume looks consistent across different devices and platforms.

Generating Different Formats

With Git and Markdown, you can generate different formats of your resume as needed. Tools like Pandoc or online services like GitHub Actions can help you automatically build PDF, DOCX, and other formats from your Markdown source.

Branching Strategies

To effectively manage different versions of your resume, consider using branching strategies. Here are a few ideas:

Main Branch: Use the master branch for your general resume.
Feature Branches: Create feature branches for specific job applications or tailored versions of your resume.
Styling Branches: Experiment with different styling and formatting in dedicated branches.

Collaboration and Sharing

If you're working with others on your resume or seeking feedback, Git simplifies the process. You can use platforms like GitHub or GitLab to host your resume repository and collaborate with colleagues or peers. Others can suggest changes, and you can easily review and incorporate their feedback.

Conclusion

Managing your resume with Git not only simplifies the process but also makes it more efficient and organized. You can maintain a history of changes, collaborate with others, and generate different formats with ease. Plus, it's a great way to ensure your resume is always up-to-date and ready for the next career opportunity.

This is the GitHub Repository of my Resume
If you have any thoughts or suggestions on how to improve my resume, please give me a comment below. Whether it's about the content, formatting, or anything else :)

Basic process management in Linux

dunkbing — Sat, 06 May 2023 19:26:28 +0000

What is a Process in Unix/Linux?

One of the notable features of Unix/Linux is the ability to run multiple programs simultaneously. The Operating System sees each executable entity it controls as a process. A program can consist of multiple processes combined. For the Operating System, processes work together to share the CPU processing speed, and use shared memory, and other system resources. Processes are scheduled in a round-robin manner by the Operating System.

As a system programmer, system administrator, or DevOps, most of your time will be spent working on Unix/Linux systems. Commands are used to interact with the operating system when working on Unix/Linux. Each command on Unix/Linux when executed will run a process or a group of processes. Therefore, understanding processes and the skills to manage and use processes on Unix/Linux systems is essential. In this article, I will introduce you to the basic knowledge and skills to manage processes on Unix/Linux systems.

Basic Terminologies

PID

Each process has a unique PID (Process Identify) throughout the system at the time the process is running.

PPID

Each process has a parent process with the identification of PPID (Parent process ID). Child processes are usually started by parent processes. A parent process can have multiple child processes, but a child process can have only one parent process.

init

The init process is the first process started after you select the Operating System in the boot loader. In the process tree, the init process is the parent process of other processes. The init process has the following characteristics: + PID = 1 + Cannot kill the init process.

kill

When a process stops running, it dies. When you want to kill a process, you need to kill it.

daemon

A daemon process is a background process. These processes are started when the system is booted up and will continue to run indefinitely.

zombie

A zombie is a leftover part of a process that has stopped working but has not been cleaned up. And, yes, zombie means zombie, meaning that process has died and you cannot "kill" it again. Programs that leave zombie processes after exiting mean that the program was poorly programmed.

Basic process management in Linux

=====================================

$$ và $PPID

Some shell environment variables contain information about processes. The variable $$ holds your current process ID and $PPID holds the PID of the parent process. In fact, $$ is a shell parameter and not a variable, you cannot assign a value to it. Below, I use the echo command to display the values of $$ and $PPID.

> $ echo $$ $PPID
2024173 1946762

pidof

With the pidof command, you can search for all process IDs by name.

> $ pidof nginx
1978170 1978169 1978168 1978167 538

parent and child

Processes have parent-child relationships. Every process has a parent process. When starting a new shell, you can use echo to verify that the previous pid is the ppid of the new shell. The above child process has become the parent process.

 > $ bash
 > $ echo $$ $PPID
2041129 2024173

Enter exit to end the current process and see the values of $$ and $PPID

 > $ bash
 > $ echo $$ $PPID
2045905 1946762
 > $ exit
 > $ echo $$ $PPID
2046134 1946762

fork và exec

A process starts another process in two stages. First, the process creates a copy (fork) of itself, exactly like it. Then, the forked process performs an execution (exec) to replace the forked process with the child process.

 > $ echo $$
2046315
 > $ bash
 > $ echo $$ $PPID
2046471 2046315
 > $

exec

With the exec command, you can execute a process without creating a new process. In the example below, the Korn shell (ksh) is launched and being replaced by a bash shell using the exec command. The PID of the bash shell is also the same as the PID of the Korn shell. Exiting the child bash shell will bring me back to the parent bash shell, not back to the Korn shell (no longer exists).

 > $ echo $$
2024173 # PID of bash
 > $ ksh
$ echo $$ $PPID
2040691 2024173
 > $ exit
exit
 > $ echo $$
2024173

One of the most common tools on Linux to view processes is ps. The following example shows the parent-child relationship between three bash processes.

 > $ echo $$ $PPID
2047247 2047214
 > $ bash
 > $ echo $$ $PPID
2047837 2047247
 > $ bash
 > $ echo $$ $PPID
2047904 2047837
 > $ ps -fx
    PID     TTY      STAT   TIME COMMAND
    2047214 ?        Ss     0:00  \_ sshd: root@pts/44
    2047247 pts/44   Ss     0:00  |   \_ -bash
    2047837 pts/44   S      0:00  |       \_ bash
    2047904 pts/44   S      0:00  |           \_ bash
    2047977 pts/44   R+     0:00  |               \_ ps -fx
 > $ exit
exit
 > $ ps -fx
    PID     TTY      STAT   TIME COMMAND
    2047214 ?        Ss     0:00  \_ sshd: root@pts/44
    2047247 pts/44   Ss     0:00  |   \_ -bash
    2047837 pts/44   S      0:00  |       \_ bash
    2048248 pts/44   R+     0:00  |           \_ ps -fx
 > $ exit
exit
 > $ ps -fx
    PID     TTY      STAT   TIME COMMAND
    2047214 ?        Ss     0:00  \_ sshd: root@pts/44
    2047247 pts/44   Ss     0:00  |   \_ -bash
    2048522 pts/44   R+     0:00  |       \_ ps -fx
 > $

On Linux, ps -fax is a commonly used command. On Solaris, ps -ef (which also works on Linux) is more popular. Here is a sample output from the ps -fax command:

 > $ ps -fax
PID TTY STAT TIME COMMAND
1 ? S 0:00 init [5]
...
2046788 ?        Ss     0:00  \_ sshd: [accepted]
2046789 ?        S      0:00  |   \_ sshd: [net]
2047214 ?        Ss     0:00  \_ sshd: root@pts/44
2047247 pts/44   Ss     0:00      \_ -bash
2047273 pts/44   R+     0:00          \_ ps -fax

pgrep

Just like ps -C, you can utilize pgrep to find a process by its command name.

 > $ sleep 1000 &
[1] 2048730
 > $ pgrep sleep
2048730
 > $ ps -C sleep
    PID TTY          TIME CMD
2048730 pts/44   00:00:00 sleep

You can also list the command name of a process with pgrep.

 > $ pgrep -l sleep
2048730 sleep

top

A popular and perhaps familiar tool for Linux users is top. The tool can show a table of currently running processes in real-time, as well as the CPU and memory usage of the system. it also provides many different options that allow you to sort processes by CPU, usage, or other attributes. Additionally, you can kill processes with top. Overall, I think this is an important tool that is both intuitive and easy to use for Linux system administrators in general.

The main parameters for the top command are:

-h - Display the current version
-c - This parameter toggles the command column state from showing command names to program names and vice versa
-d - Specify the delay time when refreshing the screen
-o - Sort by a named field
-p - Display only processes with specified IDs
-u - Display only processes of a specified user
-i - Do not display idle tasks

Additionally, while top is running, you can enable and disable many features, change the display by pressing relevant keys. The top command has some additional parameters, you can learn more about them by using the man top command on the command line.

Conclusion

Above, I have just shared some basic skills and frequently used commands to manage processes on Unix/Linux operating systems.

Thank you for reading!

Terminal chat application

dunkbing — Sun, 28 Aug 2022 19:56:34 +0000

Overview of My Submission

A very simple chat application inside the terminal. The app uses the pubsub to publish the messages to other channel, implemented using Golang which is the programing language that I recently learn.

Submission Category:

Wacky Wildcards

Language Used

Go 1.18 for developing the app.
Use the bubbletea framework for making the terminal ui.

Link to Code

dunkbing / tchat

A simple chatapp with Golang and Redis Pub/Sub

Terminal chat application

A simple chat application inside the terminal with Golang and Redis Pub/Sub.

How it works

How the data is stored:

The chat data is stored as keys
- For each channel contents, the channel: is the prefix key, followed by the channel name.
- For each message contents, the message: is the prefix key, followed by the channel-name and the message-data in json format.

How the data is accessed:

Here is the sample code to access the channel's messages with Go Redis:

# Get the channel's messages
ctx := context.Background()
iter := redis.Client.Scan(ctx, 0, fmt.Sprintf("%s%s*", messagePrefix, m.channel), 0).Iterator()  
var messages []string  
for iter.Next(ctx) {  
   rawMsg := iter.Val()  
   rawMsg = strings.Replace(rawMsg, fmt

…

View on GitHub

Additional Resources / Info

None

Collaborators

@dunkbing