DEV Community: amekusa03

Building GXBackup: A Smart, Load-Aware Linux Backup Utility in C++17 and Qt 6

amekusa03 — Tue, 18 Aug 2026 23:39:56 +0000

🚀 Building GXBackup: A Smart, Load-Aware Linux Backup Utility in C++17 and Qt 6

When working on Linux desktops or development workstations, backups are essential. However, many existing GUI backup utilities suffer from common drawbacks:

They are heavy Electron wrappers that consume hundreds of megabytes of RAM.
They hog system resources during background backup tasks, causing stuttering while compiling code or rendering assets.
They lack granular control over resource usage and desktop integration.

To solve this, I created GXBackup — a fast, lightweight, native C++17 and Qt 6/Qt 5 application for Linux. It combines the bulletproof reliability of rsync with a modern UI, system tray integration, and smart CPU/load-aware auto-pausing.

Here is an overview of how GXBackup works, its key features, and some of the technical design decisions behind it.

🌟 Key Features at a Glance

📸 Time Machine Style Snapshots: Uses rsync's --link-dest option to create incremental point-in-time snapshots using hardlinks, saving significant disk space.
⚡ Smart Load Throttling: Monitors /proc/stat and /proc/loadavg in real time. If CPU usage or load average exceeds configured thresholds, GXBackup automatically pauses the backup job and resumes it once the system cools down.
⏰ Automated Scheduling & Catch-Up: Set daily or weekly backup schedules. If your machine was powered off during a scheduled run, GXBackup detects the missed run at boot and executes a "catch-up" backup automatically.
🔔 System Tray & Desktop Integration: Operates quietly in the background with minimal memory footprint and native notification support.
🌐 Dynamic Runtime i18n: Ships in English by default with dynamic runtime language switching (e.g., Japanese/English) without requiring an app restart.

🛠 Tech Stack & Architecture

Language: C++17
Framework: Qt 6 / Qt 5 (Core, Gui, Widgets, Concurrent)
Backend Engine: rsync
Build System: CMake (3.16+)

Project Structure

GXBackup/
├── CMakeLists.txt         # Build configuration
├── resources/             # Icons & embedded Qt resources (.qrc)
├── translations/          # Translation files (.ts / .qm)
└── src/
    ├── main.cpp           # Entry point & CLI argument parsing
    ├── core/              # Core logic & backend
    │   ├── AutostartManager.cpp  # XDG desktop autostart manager
    │   ├── BackupController.cpp  # Backup workflow coordinator
    │   ├── HistoryManager.cpp   # Execution history persistence
    │   ├── LanguageManager.cpp  # Dynamic i18n & QTranslator manager
    │   ├── ProfileManager.cpp   # Profile configuration (JSON)
    │   ├── RsyncProcess.cpp     # rsync process lifecycle & progress parser
    │   ├── ScheduleManager.cpp  # Cron-like timer & missed run detector
    │   └── SystemMonitor.cpp    # Real-time /proc resource reader
    └── ui/                # Qt GUI & dialogs
        ├── HistoryDialog.cpp    # History table view
        ├── LogViewer.cpp        # Console log output window
        ├── MainWindow.cpp       # Main dashboard & tray icon
        └── ProfileDialog.cpp    # Profile configuration editor

💡 Deep-Dive: What Makes GXBackup Unique?

1. Smart Resource Throttling (`SystemMonitor`)

One of the biggest pain points of background backups on developer machines is resource contention. If rsync starts indexing thousands of files while you are running cmake --build or docker build, your PC can lock up.

GXBackup addresses this by inspecting system metrics directly from /proc:

// Reading CPU & Load Average from Linux pseudo-filesystems
void SystemMonitor::checkMetrics()
{
    double cpuUsage = readCpuUsagePercent();
    double loadAvg = readLoadAverage1Min();

    emit metricsUpdated(cpuUsage, loadAvg);

    bool highLoad = (cpuUsage >= m_cpuThreshold) || (loadAvg >= m_loadAvgThreshold);
    if (highLoad != m_isHighLoadState) {
        m_isHighLoadState = highLoad;
        emit loadStateChanged(m_isHighLoadState);
    }
}

When high load is detected, BackupController intercepts the event and signals RsyncProcess to pause execution, ensuring your desktop stays responsive.

2. Native rsync Execution & Real-Time Progress Parsing

Rather than wrapping rsync blindly, GXBackup launches rsync asynchronously via QProcess and parses its output stream (--progress format) in real time to calculate:

Transfer percentage
Current transfer speed (MB/s)
Transferred data size
Estimated time remaining (ETA)

void RsyncProcess::parseProgress(const QString &line)
{
    // Regular expression parsing of rsync --progress output lines:
    // "  1,234,567  45%  12.34MB/s  0:00:15"
    static QRegularExpression re(R"(\s*([\d,]+)\s+(\d+)%\s+([\d\.]+\w+/s)\s+([\d:]+))");
    QRegularExpressionMatch match = re.match(line);

    if (match.hasMatch()) {
        int percent = match.captured(2).toInt();
        QString speed = match.captured(3);
        QString transferred = formatBytes(match.captured(1).remove(',').toULongLong());
        QString eta = match.captured(4);

        emit progressUpdated(percent, speed, transferred, eta);
    }
}

3. Dynamic i18n & Instant Language Switcher

In Qt applications, switching languages usually requires restarting the app. GXBackup uses a custom LanguageManager singleton that loads .qm binary translation files from Qt's resource system (:/translations/gxbackup_ja.qm) and broadcasts dynamic QEvent::LanguageChange events.

All UI windows override changeEvent:

void MainWindow::changeEvent(QEvent *event)
{
    if (event->type() == QEvent::LanguageChange) {
        retranslateUi();
    }
    QMainWindow::changeEvent(event);
}

This allows users to switch between English and Japanese on the fly from the Settings -> Language menu with zero restart downtime!

💻 Getting Started

Prerequisites

For Ubuntu / Debian:

sudo apt update
sudo apt install build-essential cmake qt6-base-dev rsync

Build & Run

# Clone repository
git clone https://github.com/amekusa03/GXBackup.git
cd GXBackup

# Build project
mkdir build && cd build
cmake ..
make -j$(nproc)

# Run GUI
./GXBackup

👥 Open Source & Feedback

GXBackup is open source under the MIT License.

🐙 GitHub Repository: github.com/amekusa03/GXBackup
🐞 Issues & Feature Requests: Contributions and feedback are welcome!

If you are looking for a fast, responsive backup tool for your Linux desktop or home server, give GXBackup a try!

Tags: #linux #cpp #qt #opensource

Never Forget What You Ordered: Building 'Lunch Memo' with Jetpack Compose, Room, and AlarmManager

amekusa03 — Wed, 01 Jul 2026 09:50:02 +0000

Never Forget What You Ordered: Building "Lunch Memo" with Jetpack Compose, Room, and AlarmManager

Have you ever stood in line at a cafeteria or ticket machine, thinking: "Did I order the Lunch Special A or B today?"

For many developers working at companies with pre-ordered lunch systems, this is a daily micro-friction. You reserve a lunch days in advance, only to stand in front of the cashier trying to recall what you picked.

To solve this, I built Lunch Memo—a sleek, lightweight Android application designed to keep track of daily lunch plans and send a notification right before lunch.

In this article, I’ll walk through the implementation highlights, showcasing:

Interactive UI: Creating a fluid calendar card swiping animation with Jetpack Compose HorizontalPager and graphicsLayer.
Modular Architecture: A customizable 3-component input form (Selection, Numeric, Text) backed by Room and serialized JSON.
Exact Alarms: Scheduling reliable daily notifications using AlarmManager, BroadcastReceiver.goAsync(), and Kotlin Coroutines.
Data Stewardship: Auto-cleaning database records to keep the app's footprint tiny.

🛠️ The Tech Stack

Language: Kotlin
UI: Jetpack Compose (Material 3)
Database: Room (SQLite)
Scheduling: AlarmManager + BroadcastReceiver
Asynchronous: Coroutines & Flow
Architecture: MVVM
Dependency Management: Gradle Version Catalog

🎨 1. Fluid Card Swipe Animation with Jetpack Compose

To make navigating dates feel premium, the app displays lunch memos as cards in a horizontal calendar. Swiping left or right changes the day.

Instead of a static list, I used HorizontalPager and manipulated the cards dynamically via graphicsLayer. The active card stands out, while adjacent cards are scaled down and made translucent based on their scroll offset.

Here is the implementation:

@Composable
fun LunchMemoContent(
    memos: Map<LocalDate, String>,
    settings: AppSettingsEntity?,
    onMemoChange: (LocalDate, String) -> Unit
) {
    val pageCount = 2000
    val initialPage = pageCount / 2
    val pagerState = rememberPagerState(pageCount = { pageCount }, initialPage = initialPage)
    val today = LocalDate.now()

    HorizontalPager(
        state = pagerState,
        contentPadding = PaddingValues(horizontal = 44.dp),
        pageSpacing = 16.dp,
        modifier = Modifier.fillMaxSize(),
        verticalAlignment = Alignment.CenterVertically
    ) { page ->
        val date = today.plusDays((page - initialPage).toLong())
        val isSelected = pagerState.currentPage == page

        // Calculate scroll offset fraction
        val pageOffset = (
            (pagerState.currentPage - page) + pagerState.currentPageOffsetFraction
        ).absoluteValue

        LunchMemoCard(
            date = date,
            memo = memos[date] ?: "",
            isEditable = isSelected,
            settings = settings,
            onMemoChange = { onMemoChange(date, it) },
            modifier = Modifier.graphicsLayer {
                // Scale and fade cards based on offset fraction
                val fraction = 1f - pageOffset.coerceIn(0f, 1f)
                alpha = lerp(start = 0.5f, stop = 1f, fraction = fraction)
                scaleX = lerp(start = 0.85f, stop = 1f, fraction = fraction)
                scaleY = lerp(start = 0.85f, stop = 1f, fraction = fraction)
            }
        )
    }
}

Why this works:

graphicsLayer applies changes (like scale and alpha) on the GPU level without triggering recomposition. This keeps animations running at a locked 60/120 FPS.
The lerp (linear interpolation) function smoothly maps scroll offsets to visual properties.

⚙️ 2. Dynamic 3-Component Input Form

Users need different types of memos. For example, you might want to:

Select a pre-configured lunch package (e.g., "A Lunch", "B Lunch").
Type in a table or reservation number (Numeric).
Write custom notes (Text).

To support this without over-complicating the schema, the app represents the memo as a single string composed of three space-separated parts ("Part1 Part2 Part3"). In the UI, these are rendered as three configurable components:

@Composable
fun LunchMemoCard(
    date: LocalDate,
    memo: String,
    isEditable: Boolean,
    settings: AppSettingsEntity?,
    onMemoChange: (String) -> Unit,
    modifier: Modifier = Modifier
) {
    // Parse the space-separated parts
    val parts = remember(memo) { 
        val p = memo.split(" ")
        mutableStateListOf(
            if (p.isNotEmpty()) p[0] else "",
            if (p.size > 1) p[1] else "",
            if (p.size > 2) p.subList(2, p.size).joinToString(" ") else ""
        )
    }

    fun updateMemo() {
        onMemoChange(parts.joinToString(" ").trim())
    }

    // ... Layout and Header ...
    Column(modifier = Modifier.weight(1f).fillMaxWidth()) {
        if (isEditable) {
            ComponentInput(1, config1, parts[0]) { parts[0] = it; updateMemo() }
            Spacer(modifier = Modifier.height(12.dp))
            ComponentInput(2, config2, parts[1]) { parts[1] = it; updateMemo() }
            Spacer(modifier = Modifier.height(12.dp))
            ComponentInput(3, config3, parts[2]) { parts[2] = it; updateMemo() }
        } else {
            // Display consolidated text view
        }
    }
}

Each ComponentInput displays a different UI depending on its active configuration:

SELECTION renders custom tags as a flow of FilterChips.
NUMERIC restricts input to a specified number of digits.
TEXT displays a simple text input.

@Composable
fun ComponentInput(
    index: Int,
    config: ComponentConfig,
    value: String,
    onValueChange: (String) -> Unit
) {
    Column(modifier = Modifier.fillMaxWidth()) {
        Text("Component $index", style = MaterialTheme.typography.labelSmall)

        when (config.type) {
            ComponentType.SELECTION -> {
                FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    config.options.forEach { option ->
                        FilterChip(
                            selected = value == option,
                            onClick = { onValueChange(option) },
                            label = { Text(option) }
                        )
                    }
                }
            }
            ComponentType.NUMERIC -> {
                OutlinedTextField(
                    value = value,
                    onValueChange = { 
                        if (it.length <= config.digitLimit && it.all { it.isDigit() }) {
                            onValueChange(it)
                        }
                    },
                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
                    placeholder = { Text("${config.digitLimit}-digit number") }
                )
            }
            ComponentType.TEXT -> {
                OutlinedTextField(value = value, onValueChange = onValueChange)
            }
        }
    }
}

⏰ 3. Precision Local Notifications via AlarmManager & Coroutines

Using WorkManager for a daily alarm is standard practice, but WorkManager is built for deferrable background work. It operates on a sliding window and cannot guarantee execution at an exact minute (like exactly 12:00 PM).

To wake the device and post the notification at the exact minute, Lunch Memo uses AlarmManager combined with a BroadcastReceiver.

Triggering the Alarm

We calculate the delay until the user's configured notification time (adjusting to the next day if that time has already passed) and schedule the alarm using setExactAndAllowWhileIdle:

object NotificationScheduler {
    private const val REQUEST_CODE = 1001

    fun scheduleDailyNotification(context: Context, hour: Int, minute: Int) {
        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
        val intent = Intent(context, NotificationReceiver::class.java).apply {
            action = "com.kusa.lunchmemo.NOTIFICATION_ALARM"
        }
        val pendingIntent = PendingIntent.getBroadcast(
            context, REQUEST_CODE, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        val calendar = Calendar.getInstance().apply {
            set(Calendar.HOUR_OF_DAY, hour)
            set(Calendar.MINUTE, minute)
            set(Calendar.SECOND, 0)
            set(Calendar.MILLISECOND, 0)
            if (timeInMillis <= System.currentTimeMillis() + 1000) {
                add(Calendar.DATE, 1)
            }
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            if (alarmManager.canScheduleExactAlarms()) {
                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
            } else {
                alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
            }
        } else {
            alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
        }
    }
}

Performing Async Tasks in a BroadcastReceiver with `goAsync()`

Typically, a BroadcastReceiver lifecycle is extremely short; performing operations like database queries inside onReceive can cause an Application Not Responding (ANR) error.

However, by calling goAsync(), we can safely launch a Coroutine Scope to fetch today's memo asynchronously on a dispatcher thread and keep the receiver alive until our database lookup completes:

class NotificationReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val action = intent.action
        if (action == Intent.ACTION_BOOT_COMPLETED || action == "com.kusa.lunchmemo.NOTIFICATION_ALARM") {
            // Keep BroadcastReceiver active during asynchronous execution
            val pendingResult = goAsync()

            CoroutineScope(Dispatchers.IO).launch {
                try {
                    val database = LunchMemoDatabase.getDatabase(context)
                    val dao = database.lunchMemoDao()
                    val settings = dao.getSettings().first()
                    val hour = settings?.notificationHour ?: 12
                    val minute = settings?.notificationMinute ?: 0

                    // Reschedule for tomorrow
                    NotificationScheduler.scheduleDailyNotification(context, hour, minute)

                    // Show notification if it's the alarm action
                    if (action == "com.kusa.lunchmemo.NOTIFICATION_ALARM") {
                        val today = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE)
                        val memos = dao.getAllMemos().first()
                        val todayMemo = memos.find { it.date == today }?.memo
                        if (!todayMemo.isNullOrBlank()) {
                            showNotification(context, todayMemo)
                        }
                    }
                } finally {
                    // Inform the OS we're done
                    pendingResult.finish()
                }
            }
        }
    }
}

🧹 4. Lightweight Storage & Auto-Cleanup

A good utility app shouldn't hoard local storage. Since past lunch memos are no longer relevant, Lunch Memo cleans them up automatically.

In the LunchMemoDao, I defined a simple query to delete memos older than a specified date:

@Query("DELETE FROM lunch_memos WHERE date < :date")
suspend fun deleteMemosOlderThan(date: String)

Inside the LunchMemoViewModel, this is invoked asynchronously on app launch:

fun cleanOldMemos() {
    viewModelScope.launch {
        val yesterday = LocalDate.now().minusDays(1).format(formatter)
        dao.deleteMemosOlderThan(yesterday)
    }
}

This keeps the local SQLite database extremely compact, containing only upcoming and today's memos.

🔄 5. Room Database Migrations

As the app grew, its schema evolved to accommodate customization settings. Handling migrations seamlessly is crucial so users do not lose their data.

Here is the migration trajectory of the app's database from Version 1 to 4:

v1: Basic daily notes.
v1 -> v2: Introduced app_settings for customized notification times.
v2 -> v3: Added alphanumericOnly setting.
v3 -> v4: Introduced serialization via GSON to store JSON strings representing custom layouts for the 3 input components.

private val MIGRATION_3_4 = object : Migration(3, 4) {
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE `app_settings` ADD COLUMN `component1ConfigJson` TEXT NOT NULL DEFAULT ''")
        database.execSQL("ALTER TABLE `app_settings` ADD COLUMN `component2ConfigJson` TEXT NOT NULL DEFAULT ''")
        database.execSQL("ALTER TABLE `app_settings` ADD COLUMN `component3ConfigJson` TEXT NOT NULL DEFAULT ''")

        // Define default settings layouts
        val defaultConfig1 = ComponentConfig(ComponentType.SELECTION, listOf("A Lunch", "B Lunch", "C Lunch")).serialize()
        val defaultConfig2 = ComponentConfig(ComponentType.NUMERIC, digitLimit = 2).serialize()
        val defaultConfig3 = ComponentConfig(ComponentType.TEXT).serialize()

        database.execSQL("UPDATE `app_settings` SET `component1ConfigJson` = '$defaultConfig1'")
        database.execSQL("UPDATE `app_settings` SET `component2ConfigJson` = '$defaultConfig2'")
        database.execSQL("UPDATE `app_settings` SET `component3ConfigJson` = '$defaultConfig3'")
    }
}

By adding these migration blocks to Room.databaseBuilder(...).addMigrations(...), updates are seamless and never crash the app for existing users.

🏆 Key Lessons Learned

Unidirectional Data Flow: Implementing the Room (Flow) ➔ ViewModel (StateFlow) ➔ Jetpack Compose state cycle made state updates incredibly clean and bug-free.
Choosing the Right Notification Tool: Using WorkManager is great for background syncing or analytics, but AlarmManager is the correct engineering choice when notifications must arrive at a precise local time.
Lightweight Serialized Configurations: Storing custom configurations inside the database as serialized JSON allowed adding flexible setting patterns without having to constantly spin up new Room tables.

📝 Conclusion

Building Lunch Memo was a fun project that solved a real everyday problem. It demonstrates how standard modern Android practices like Jetpack Compose, Room, and AlarmManager can create a tool that is clean, responsive, and incredibly useful.

If you struggle with remembering your cafeteria bookings, try building your own customized version!

Thanks for reading, and happy coding! 🍱

amekusa03 / androidLunchMemo

ランチ予定をシンプルに管理する Android アプリ

Lunch Memo 🍱

Lunch Memo は、日々のランチの予定や記録をシンプルかつスタイリッシュに管理できる Android アプリです。モダンな Material 3 デザインを採用し、スムーズな操作感でランチタイムを楽しく彩ります。

主な機能 🌟

スマートな記録: カレンダー形式のカードをスワイプして、ランチの内容を素早くメモ。
お昼の通知: 毎日12:00に、その日のランチメモを通知。今日何食べるんだっけ？を解消します。
モダンなデザイン:
- Material 3 フル対応。
- スムーズなカードアニメーションとグラデーション背景。
- Android 13 以上の通知権限に完全対応。
クリーンなデータ保持: 過去のメモは自動的に整理され、アプリを常に軽量に保ちます。

技術スタック 🛠️

Language: Kotlin
UI: Jetpack Compose (Material 3)
Database: Room (SQLite)
Background Tasks: WorkManager
Asynchronous: Coroutines & Flow
Architecture: MVVM
Dependency Management: Gradle Version Catalog (libs.versions.toml)
Annotation Processing: KSP (Kotlin Symbol Processing)

セットアップ 🚀

Android Studio (Ladybug 以降推奨) でプロジェクトを開きます。
プロジェクトを Gradle Sync します。
Android デバイスまたはエミュレータで実行します。

更新履歴 📅

[Lunch Memo 2.0] - 2026.07.01

選択式入力の導入: 自由入力に加え、あらかじめ登録したアイテムをタップして選択できる機能を追加。
3コンポーネント構成: メモを「選択」「数字」「文字」の3つの要素に分割。用途に合わせて自由にカスタマイズ可能に。
設定画面の強化: コンポーネントごとの入力モード切替や選択肢の編集機能を実装。
内部改善: データベースのマイグレーション(v4)と、設定保存のためのシリアライズ処理(GSON)を導入。

ライセンス 📝

このプロジェクトは MIT ライセンスの下で公開されています。

View on GitHub

Rescuing 216 Pages from the GeoCities Era: How I Built an HTML-to-Blogger Tool

amekusa03 — Fri, 03 Apr 2026 15:23:57 +0000

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience

I want to transfer the HTML format to Google Blogger.

Introduction

The outdoor club's website (which was called a homepage back then) was archived when GeoCities shut down. The last update was in April 2014.
If it had become completely inaccessible, I could have accepted it, but it's just too sad that it's become an archive.

Okay, I'll do this!
I declared to the old site administrator (a friend) "It's okay, let me do it."
For now, I'll just go with Vercel's Hobby for the new site.
Then I checked the old site's HTML
. What? 216 pages.
Doing this by hand is impossible!
The old site was beautifully made by my friend while he was learning HTML.
I tried cleaning it with AI, but my instructions were bad and it just didn't work.
With the help of another friend, I aimed to create a stylish new site using React and other things in VS Code.
While doing all that, Windows started to become unstable and eventually crashed.
The data was still there, so I reinstalled Windows and DevStudio. I lost the product ID. It 's completely over .
So I installed Ubuntu, installed VS Code, and decided to develop with Python. (I've never used it before)
While the installation was in progress, I also changed the new site's operational policy.

Members can post
You can also upload videos. With two additional requirements, the site has also been changed to Google Blogger ♫

Getting Started with Python

I started with 'Hello python' and created a CLI for tag cleaning of HTML files.
Next, I tried posting to Blogger using the API, and I'm starting to get the hang of it.

Software Requirements Definition

Ruthless decision

HTML history management
Cleaning HTML
- I want to manage the design entirely in Blogger, so I'm removing font and color settings.
Keyword extraction and registration
- Blogger allows you to set keywords for each post, so I want to use words that match the text in the HTML as keywords (e.g., kayaking, Bouldering).
Location extraction and registration
- This is also a feature that can be added to each Blogger post (Akihabara, Mt. Fuji, etc.).
Remove Exif data from images and add watermarks.
Upload articles and images
GUI

implementation

Just as you all expected, I'm totally hooked.
I was struggling to get used to Ubuntu's IME, so I installed Fcitx5 and managed to work around the problem.
I discovered that the Blogger API doesn't have image-related features → I established and standardized a somewhat easier manual + automatic linking procedure for images.
I couldn't get used to Python nesting → I ended up checking the nesting with my finger.
Library version issue occurred → Misunderstood Python virtual environment (venv) → Fumbled around trying to create an environment with virtualBox → Realized it was in the terminal and almost went blank.
I accidentally sent about 200 Blogger API requests without using a timer → I received an account lock warning email → I sent an apology email to Google and my account was restored the next day.
I installed Wine and Excel (MS-Office) to aggregate regional data → got stuck in cell input mode and switched to LibreOffice → discovered nominatim geocoding and solved the problem.
Trying to run a virtual Windows using insurance → Too slow. Insufficient HDD space. Ultimately, the license is too expensive, so I gave up.
I asked the AI to do various things, but it didn't understand the language specifications and approved them haphazardly → I ended up having to rewrite almost everything.
To create a GUI with Tkinter, you write the code → The base is written by AI, and then you just stare at the source code.
Tracing Python arguments → Why isn't copy running? → Wait, even queue instances are referenced when you put them?! And so on, intense debugging.
I can't do it well, so I end up pressing the keys too hard → My family tells me it's too loud, and I almost cry.

Reaffirming established theories

When it comes to technology, you either invest time, money, or wisdom.
For me, someone who lacks wisdom, it seems it was time.
However, I think I gained a lot.
You can't know the taste of pudding until you try it.
Ubuntu is wonderful. I dabbled in it a little for work, but I didn't know about the community at that time. Ultimately, what's important is human connection.

I would appreciate your help with debugging.

I've tried to code it so that it should work on Windows and Mac as long as you're using a Python environment.
It requires Google API authentication credentials, which is a bit of a hassle, but I'd appreciate it if you could debug it.
Even just a review would be encouraging.
Please feel free to point out any issues with the Python coding!

Introduction:

html-sigma-amber.vercel.app

Video:

code:

amekusa03 / html-blogger

htmlからGoogle Bloggerへ変換とアップロードをサポートします

HTML to Blogger Ver0.98

A desktop application that automatically processes local HTML files and images and posts them to Blogger.
It performs HTML cleaning, adds watermarks to images, assigns keywords and location information, and uploads to Blogger.

Qiita Article

Explanation article for this tool (Qiita)

Introduction Video

Main Features

HTML Cleaning: Removes unnecessary tags and normalizes formatting for posts.
Image Processing: Removes EXIF data and adds watermarks.
Metadata Assignment: Automatically adds keywords (search tags) and location information (georss tags) by analyzing the article content.
Blogger Upload: Uploads image links and articles as drafts using the Blogger API.
GUI Operation: User-friendly GUI with progress visualization and error recovery features.

Processing Flow

Processing is executed in the following order:

import_file.py: Imports files from the source folder to the working folder.
serial_file.py: Converts file names into sequential numbering format.
clean_html.py: Cleans up HTML…