Forem: Chanh Le

Managing Background Services with Supervisor

Chanh Le — Fri, 19 Sep 2025 02:51:42 +0000

I’ve been using Supervisor lately to manage background services, and it’s been surprisingly handy.

What stands out to me is how flexible it is: you can update the configuration from the CLI, reload it, and even scale the number of processes — all without restarting the ones that are already running. That’s a big deal if you care about avoiding downtime.

A few things I find useful:

Start, stop, and restart services individually
Reload configs on the fly
Adjust the number of worker processes without taking everything down

It’s not fancy, but it gets the job done and keeps process management straightforward.

Concurrent programming in Java: ThreadPoolExecutor back-pressure

Chanh Le — Fri, 19 Sep 2025 02:47:55 +0000

I recently discovered that Java’s ThreadPoolExecutor comes with a built-in back-pressure mechanism, and it’s surprisingly useful.

Consider a scenario where you use a thread pool to process large data encryption tasks. To avoid running into an OutOfMemoryError, you’d normally need to implement a way to slow down or block the threads submitting tasks.

With ThreadPoolExecutor, this is straightforward: simply configure the RejectedExecutionHandler to use CallerRunsPolicy.

This setting forces the submitting thread to execute the task itself whenever the pool and its queue are saturated. Since the submitting thread is now busy doing work, it naturally slows down task submission — effectively applying back-pressure.

Simple and elegant, right?

Spring Integration: What is it?

Chanh Le — Wed, 10 Sep 2025 08:47:29 +0000

I am working a project using Spring Integration for encrypting some PHI files.

The system is responsible for scanning input files a folder, then perform some encryption, and finally upload the output to another folder.

However, the input and output folders are actually remote folders, which the system can connect via SFTP.

With Spring Integration, you can imagine that you don't need to write code for interacting with the SFTP servers. All you need is some configuration using XML-based or Annotation-based.

By that, you can focus on the main tasks - encryption.

The workflow will have these main steps:

Scan for input files on input SFTP folder using an InboundChannelAdapter with SFTP protocol. The output of this step will be a Message on a Channel (named processingChannel).
Consume messages from the channel and do encryption, then build another message with the output and push it into another channel (named deliveringChannel).
Finally, an OutboundChannelAdapter, will consume messages from the deliveringChannel and upload it to the output SFTP.

You can configure all 3 steps very easy and simple.
Then, there is only left for you to do is implementing the main business - encrypt the files.

You can see that our encryption service is actually the consumer of the processingChannel. And we can scale this consumer by using different kinds of channel: DirectChannel (for point-to-point consuming; ExecutorChannel for fanning out the messages to all threads inside a thread-pool; Pub/Sub Channel for multiple consumers.

Let's configure the channels:

ChannelConfig.java

@Configuration
@EnableIntegration
public class ChannelConfig {

    @Bean
    public MessageChannel processingChannel() {
        return new ExecutorChannel(Executors.newFixedThreadPool(10));
    }

    @Bean
    public MessageChannel deliveringChannel() {
        return new ExecutorChannel(Executors.newFixedThreadPool(10));

    }
}

Both channels are ExecutorChannel which use a ThreadPool to handle messages concurrently.

Here is the configuration for Inbound Channel Adapter.

SftpInboundConfig.java

@Configuration
@EnableIntegration
public class SftpInboundConfig {

    @Bean
    public SessionFactory<SftpClient.DirEntry> sftpSessionFactory() {
        DefaultSftpSessionFactory factory = new DefaultSftpSessionFactory(true);
        factory.setHost(host);
        factory.setPort(port);
        factory.setUser(user);
        factory.setPassword(password);
        factory.setAllowUnknownKeys(true);
        return factory;
    }

    @Bean
    public IntegrationFlow sftpInboundFlow() {
        return IntegrationFlow
                .from(
                        Sftp.inboundAdapter(sftpSessionFactory())
                                .remoteDirectory(remoteDir)
                                .localDirectory(new File(localDir)),
                        e -> e.id("sftpInboundAdapter")
                                .autoStartup(true)
                                .poller(Pollers.fixedDelay(1000))
                )
                .channel("processingChannel")
                .get()
    }
}

We define a SFTP session factory for creating session/connection to input SFTP server. The sftpInboundFlow will use this factory to create session and download files from Input SFTP server.

And here is for Outbound Channel Adapter.

SftpOutboundConfig.java

@Configuration
@EnableIntegration
public class SftpOutboundConfig {

    @Bean
    public SessionFactory<SftpClient.DirEntry> sftpOutboundSessionFactory() {
        DefaultSftpSessionFactory factory = new DefaultSftpSessionFactory(true);
        factory.setHost(host);
        factory.setPort(port);
        factory.setUser(user);
        factory.setPassword(password);
        factory.setAllowUnknownKeys(true);
        return factory;
    }

    @Bean
    public IntegrationFlow outboundFlow() {
        return IntegrationFlow.from("deliveringChannel")
                .handle(Sftp.outboundAdapter(sftpOutboundSessionFactory())
                        .remoteDirectory(remoteDir)
                        .autoCreateDirectory(true)
                )
                .get();
    }
}

We also define a SFTP session factory for output SFTP server. The outboundFlow will use this factory to create session and upload encrypted files to output SFTP server.

Wiring with our main business

And finally, we need to map our EncryptionService with processingChannel and deliveringChannel. This service will consume messages from processingChannel, do encryption and push another message to deliveringChannel.

ProcessingFlowConfig.java

@Configuration
@EnableIntegration
public class ProcessingFlowConfig {

    @Bean
    public IntegrationFlow processFlow() {
        return IntegrationFlow.from("processingChannel")
                .handle("encryptionService", "encrypt")
                .channel("deliveringChannel")
                .get();
    }

}

We use IntegrationFlow to consume messages from processingChannel and call encryptionService.encrypt method to do encryption and output messages will be pushed to deliveringChannel.

Let's pretend we have a simple EncryptionService like this:
EncryptionService.java

@Service
public class EncryptionService {

    public Message<File> encrypt(Message<File> message) {
        File encrypted = doSomeEncryption(message.getPayload());
        return MessageBuilder.withPayload(encrypted).build();
    }
}

Just like that. We're done.

Conclusion

With Spring Integration, we can seamlessly connect systems, services, and components by using adapters, channels, and integration flows. This allows us to shift our focus away from the plumbing of connectivity and instead concentrate on our core business — processing and transforming messages and data across multiple systems within our enterprise and integrating with external services from partner organizations.

Strategy Pattern: simple but powerful

Chanh Le — Mon, 08 Sep 2025 06:52:37 +0000

Any time you want to add a new feature, think of it like another strategy of your system.
In your code, you just need to add another switch case for initiating your new strategy and all your new code will be added there.
No side-effects, no breaking-changes.
It's really that simple and yet powerful - Strategy Pattern.

Make a Calendar app with SwiftUI - part 2

Chanh Le — Sun, 07 Sep 2025 06:56:56 +0000

In part 1, I did show you how to build a simple Calendar App with SwiftUI. This part 2 will continue to show how to load data from SQLite so we can see the lunar date of each solar date.

Add SQLite package to Xcode project

I am using this package for working with SQLite on Swift. You just need to add it to Xcode like this.

After adding SQLite, we add this file for connecting SQLite lunar_calendar.db.
LunarDatabase.swift

import Foundation
import SQLite

struct LunarDate: Hashable {
    let solarDate: String
    let year: Int
    let month: Int
    let day: Int
    let isLeapMonth: Bool
}

class LunarDatabase {
    private let db: Connection


    init?() {
        guard let dbPath = Bundle.main.path(forResource: "lunar_calendar", ofType: "db") else {
            print("❌ Database file not found in bundle")
            return nil
        }

        do {
            db = try Connection(dbPath, readonly: true)
        } catch {
            print("❌ Failed to open DB: \(error)")
            return nil
        }
    }

    func query(for date: Date) -> LunarDate? {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        let dateStr = formatter.string(from: date)

        do {
            // Raw SQL with parameter binding
            let sql = "SELECT solar_date, lunar_year, lunar_month, lunar_day, is_leap_month FROM lunar_dates WHERE solar_date = ? LIMIT 1"
            let stmt = try db.prepare(sql)

            // Run the statement with dateStr as parameter
            for row in try stmt.run(dateStr) {
                return LunarDate(
                    solarDate: row[0] as! String,
                    year: Int(row[1] as! Int64),   // SQLite returns Int64
                    month: Int(row[2] as! Int64),
                    day: Int(row[3] as! Int64),
                    isLeapMonth: (row[4] as! Int64) == 1
                )
            }
        } catch {
            print("Query error: \(error)")
        }
        return nil
    }

We have a table called lunar_dates with schema like this:

We now can extend the Date by adding toLunar method to load lunar date from SQLite.
Date+Extension.swift


let lunarDB = LunarDatabase()

extension Date {
    func toLunar() -> LunarDate? {
        return lunarDB?.query(for: self)
    }
}

Now, let's extend Calendar by adding methods to collect week days, month days like below:
Calendar+Extension.swift


struct CalendarDay: Identifiable, Hashable {
    var id: Date { solar }   // unique per day
    let solar: Date
    let lunar: LunarDate
    let gregorianDay: Int
    let lunarDay: String
    let isToday: Bool
    let isHoliday: Bool
    let isSpecialDay: Bool
}

extension Calendar {

    func lunarDay(for solar: Date = Date()) -> CalendarDay {
        let lunar = solar.toLunar()!
        let lunarDay = lunar.day
        var lunarDayStr = "\(lunarDay)"
        if lunarDay == 1 {
            let lunarMonth = lunar.month
            lunarDayStr = "\(lunarDay)/\(lunarMonth)"
        }

        return CalendarDay(
            solar: solar,
            lunar: lunar,
            gregorianDay: component(.day, from: solar),
            lunarDay: lunarDayStr,
            isToday: isDateInToday(solar),
            isHoliday: holiday(solar, lunar) != nil,
            isSpecialDay: specialDay(solar, lunar) != nil
        )
    }

    func weekDays(for date: Date) -> [CalendarDay] {
        let startOfWeek = self.startOfWeek(for: date)
        return (0..<7).map { offset in
            let d = self.date(byAdding: .day, value: offset, to: startOfWeek)!
            return self.lunarDay(for: d)
        }
    }

    func monthDays(for date: Date) -> [CalendarDay] {
        guard let monthInterval = self.dateInterval(of: .month, for: date),
              let monthFirstWeek = self.dateInterval(of: .weekOfMonth, for: monthInterval.start),
              let monthLastWeek = self.dateInterval(of: .weekOfMonth, for: monthInterval.end.addingTimeInterval(-1))
        else { return [] }

        // Correct end: subtract 1 day because `end` is exclusive
        let lastVisibleDay = self.date(byAdding: .day, value: -1, to: monthLastWeek.end)!
        let fullRange = monthFirstWeek.start...lastVisibleDay

        var days: [CalendarDay] = []
        var current = fullRange.lowerBound

        while current <= fullRange.upperBound {
            days.append(self.lunarDay(for: current))
            current = self.date(byAdding: .day, value: 1, to: current)!
        }

        return days
    }

    func weekNumber(for date: Date) -> Int {
        return self.component(.weekOfYear, from: date)
    }

    func startOfWeek(for date: Date) -> Date {
        let comps = dateComponents([.yearForWeekOfYear, .weekOfYear], from: date)
        return self.date(from: comps)!
    }

}

These added methods will be used for producing input for MonthView and WeekView of the app.

You can check full source code here.

Next time, I will show you how to generate the lunar_calendar.db using lunardate Python package.

Async programming: AsyncIO

Chanh Le — Thu, 04 Sep 2025 17:57:30 +0000

Asyncio in Python is about writing concurrent code using the async/await syntax. It’s not parallelism (that’s multiprocessing or threads), but it lets you handle many I/O-bound tasks without blocking.

Think: downloading 100 web pages, handling thousands of socket connections, or waiting on a database — asyncio makes it scalable and efficient.

Core Concepts

Event loop: the “engine” that runs your coroutines.
Coroutine: an async function you can pause (await) and resume.
Task: a coroutine scheduled on the event loop.

Basic Coroutine

import asyncio

async def say_hello():
    print("Hello...")
    await asyncio.sleep(1)  # non-blocking sleep
    print("...World!")

asyncio.run(say_hello())

Key things here:

async def defines a coroutine.
await suspends execution until the awaited task is done.
asyncio.sleep is non-blocking, unlike time.sleep.

Running Multiple Coroutines

import asyncio

async def worker(name, delay):
    print(f"{name} started")
    await asyncio.sleep(delay)
    print(f"{name} finished after {delay}s")

async def main():
    # Schedule tasks concurrently
    task1 = asyncio.create_task(worker("A", 2))
    task2 = asyncio.create_task(worker("B", 1))

    await task1
    await task2

asyncio.run(main())

Even though worker A takes 2 seconds and worker B takes 1 second, the total runtime is about 2 seconds, not 3. That’s concurrency.

Gathering Tasks

Instead of awaiting them one by one:

await asyncio.gather(worker("A", 2), worker("B", 1))

This runs both concurrently and returns results in order.

Example: Fetching URLs

import asyncio
import aiohttp  # pip install aiohttp

async def fetch(session, url):
    async with session.get(url) as resp:
        return await resp.text()

async def main():
    urls = [
        "https://example.com",
        "https://httpbin.org/get",
        "https://python.org",
    ]
    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(*(fetch(session, u) for u in urls))
        for url, result in zip(urls, results):
            print(f"Fetched {url[:30]}... {len(result)} bytes")

asyncio.run(main())

Here, instead of fetching one page at a time, all requests are fired together. Big win in speed.

Things to remember

Use asyncio.run() to start your program.
Use await only inside async def.
CPU-bound tasks don’t belong in asyncio. For those, use concurrent.futures with threads or processes.
asyncio is single-threaded. It just pauses/wakes tasks on I/O, not multiple CPU execution.

Conclusion

Using asyncio is like writing Javascript or Typescript. You will see async/await there as well. The mechanism is the same, both are using event loop under the hood.
For Python developers, in the past we usually used ThreadPool for concurrent programming. This requires us to manage the pool and identify beforehand how big (how many threads) the pool should be. With asyncio, we don't have to anymore and I really love this. Now, I just use asyncio to write code without concerning about the pool size.

Make a Calendar app with SwiftUI - part 1

Chanh Le — Thu, 04 Sep 2025 17:54:44 +0000

I assume you can find out how to setup a SwiftUI project using Xcode. So, I will jump right into how to build calendar views and load data from SQLite.

App Views

We will make a very simple app with only 2 views: MainView for displaying current month and DetailView for displaying current date and week.

View hierarchy

MainView

MainView.swift

import SwiftUI

struct MainView: View {

    @Binding var currentDate: CalendarDay
    var onSwipeUp: (() -> Void)?
    var onToday: () -> Void

    var body: some View {
        VStack(spacing: 20) {
            CalendarView(
                currentDate: $currentDate,
                onNavigate: changeMonth,
                formatTitle: monthYearString,
                onSwipeUp: onSwipeUp,
                onSwipeLeft: { withAnimation { nextMonth() } },
                onSwipeRight: { withAnimation { prevMonth() } }
            ) {
                let days = Calendar.current.monthDays(for: currentDate.solar)
                MonthView(days: days, currentDate: $currentDate)
            }

            Spacer()

            MenuView(
                mode: .month,
                onToday: onToday
            )
        }
    }


    private func changeMonth(by value: Int) {
        if let newMonth = Calendar.current.date(byAdding: .month, value: value, to: currentDate.solar) {
            currentDate = Calendar.current.lunarDay(for: newMonth)
        }
    }

    private func monthYearString(for date: CalendarDay) -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = "MMMM yyyy"
        return formatter.string(from: date.solar)
    }


    private func nextMonth() {
        // swipe left → next month
        let next = Calendar.current.date(byAdding: .month, value: 1, to: currentDate.solar)!
        currentDate = Calendar.current.lunarDay(for: next)
    }

    private func prevMonth() {
        // swipe right → previous month
        let prev = Calendar.current.date(byAdding: .month, value: -1, to: currentDate.solar)!
        currentDate = Calendar.current.lunarDay(for: prev)
    }
}

This view consists of two nested shared views: CalendarView and MenuView. They are organized in a vertical stack VStack, separated by a Spacer. Spacer is just a way to fulfill empty space between views.
This MainView is responsible for displaying calendar of current month, and navigating to next/previous month. We can swipe left/right or click left/right buttons next to month name to navigate.
The MenuView currently has only one menu: Today for going back to Today while navigating.

DetailView

DetailView.swift

import SwiftUI

struct DetailView: View {
    @Binding var currentDate: CalendarDay
    var onToday: () -> Void
    @Environment(\.dismiss) private var dismiss

    var body: some View {

        // Header with today’s date
        VStack {
            Text(currentDate.solarFormatted())
                .font(.headline)
                .foregroundColor(.gray)
            Text("Lunar: \(currentDate.lunarFormatted())")
                .font(.headline)
                .fontWeight(.semibold)
                .padding(.vertical, 5)

            CalendarView(
                currentDate: $currentDate,
                onNavigate: changeWeek,
                formatTitle: formatWeek,
                onSwipeLeft: nextWeek,
                onSwipeRight: prevWeek,
                onSwipeDown: { dismiss() }
            ) {
                let days = Calendar.current.weekDays(for: currentDate.solar)
                WeekView(days: days, currentDate: $currentDate)

                if currentDate.isHoliday {
                    HolidayView(currentDate: $currentDate)
                }

            }

            Spacer()

            // Bottom Navigation
            MenuView(
                mode: .home,
                onToday: onToday
            )
        }
        .padding()
        .contentShape(Rectangle())

    }

    private func changeWeek(_ by: Int) {
        if let newDate = Calendar.current.date(byAdding: .weekOfYear, value: by, to: currentDate.solar) {
            currentDate = Calendar.current.lunarDay(for: newDate)
        }
    }

    private func formatWeek(_ date: CalendarDay) -> String {
        let week = Calendar.current.dateComponents([.weekOfYear, .year], from: date.solar)
        let prefix = String(localized: "week")
        return "\(prefix) \(week.weekOfYear!) \(week.year!)"
    }


    private func nextWeek() {
        // swipe left → next week
        let next = Calendar.current.date(byAdding: .weekOfYear, value: 1, to: currentDate.solar)!
        currentDate = Calendar.current.lunarDay(for: next)
    }

    private func prevWeek() {
        // swipe right → previous week
        let prev = Calendar.current.date(byAdding: .weekOfYear, value: -1, to: currentDate.solar)!
        currentDate = Calendar.current.lunarDay(for: prev)
    }
}

This DetailView is actually similar with MainView with some additional components for displaying current date in both solar and lunar(Vietnamese) format, following by CalendarView and MenuView.
However, this time the swipe actions and buttons will allow you to navigate between weeks instead of months.

The HomeView

Actually, the app will first load another view as entry instead of the two views above. I call this view HomeView. It is where we store the app state like current date and which views to show based on the state.

HomeView.swift

import SwiftUI

struct HomeView: View {
    @State private var currentDate  = Calendar.current.lunarDay(for: Date())
    @State private var showDetailView = false
    @State private var showSettings = false

    var body: some View {
        NavigationStack {
            MainView(
                currentDate: $currentDate,
                onSwipeUp: showDayView,
                onToday: onToday
            )
        }
        .contentShape(Rectangle())
        .sheet(isPresented: $showDetailView) {
            DetailView(
                currentDate: $currentDate,
                onToday: onToday
            )
        }
    }

    private func showDayView() {
        showDetailView = true
    }


    private func onToday() {
        currentDate = Calendar.current.lunarDay()
    }
}

The CalendarView

So far, we don't see yet where and how the swipe events are being handled. Yes, you're right. That's the shared CalendarView.

CalendarView.swift


import SwiftUI

struct CalendarView<Content: View>: View {


    @Binding var currentDate: CalendarDay
    var onNavigate: (_ by: Int) -> Void
    var formatTitle: (_ date: CalendarDay) -> String
    var onSwipeUp: (() -> Void)?
    var onSwipeLeft: (() -> Void)?
    var onSwipeRight: (() -> Void)?
    var onSwipeDown: (() -> Void)?

    @ViewBuilder var content: () -> Content


    var body: some View {
        VStack {
            HStack {
                Button(action: { onNavigate(-1) }) {
                    Image(systemName: "chevron.left")
                        .frame(width: 44, height: 44)
                        .contentShape(Rectangle())
                }
                Spacer()
                Text(formatTitle(currentDate))
                    .font(.title2)
                    .fontWeight(.bold)
                Spacer()
                Button(action: { onNavigate(1) }) {
                    Image(systemName: "chevron.right")
                        .frame(width: 44, height: 44)
                        .contentShape(Rectangle())
                }
            }
            .padding()

            Divider()

            content()

            Spacer()

        }
        .contentShape(Rectangle()) // make whole area hittable
        .gesture(
            DragGesture()
                .onEnded { value in
                    if value.translation.height < -50 { // swipe up
                        onSwipeUp?()
                    } else if value.translation.width < -50 { // swipe left
                        onSwipeLeft?()
                    } else if value.translation.width > 50 { // swipe right
                        onSwipeRight?()
                    } else if value.translation.height > 50 { // swipe down
                        onSwipeDown?()
                    }
                }
        )
    }

}

This view is responsible for capturing swift events and calling the event handlers which are passed from parent view of this CalendarView. This view is being reused across MainView and DetailView. Each views is providing different handlers for the swipe events. That's swiping on MainView will allow you to navigate between although on DetailView you will be navigated between weeks.

You might also see the onNavigate handler. Yes, this is the handler for left/right buttons next to the title of the CalendarView. This title is also flexible, depends on what the parent view provided.
About the onToday handler, it is used for handling the Today button's click event. And you might guess it is the MenuView's responsibility to catch the event and map it with the corresponding handler.

Conclusion

You can use VStack and HStack for organizing views. You can capture events using gestures or actions(events). You can pass event handlers via View constructor. You can store state at the root/entry view and bind state using @Binding annotation. Which binding you can modify the state at anywhere.

Next, I will continue with part 2 - loading lunar data from SQLite.

You can see the source code of this app here.

Make a GUI app with Python

Chanh Le — Thu, 04 Sep 2025 17:53:27 +0000

What is tkinter?

Tkinter is Python’s standard GUI (Graphical User Interface) library.

Built-in: You don’t need to install it separately if you have the default Python distribution - it ships with Python.
Wrapper: It’s a thin object-oriented wrapper around Tcl/Tk, which is an older but very stable GUI toolkit.
Purpose: Lets you build desktop applications with windows, buttons, labels, menus, text boxes, etc.

Think of it as Python’s way to make actual windows instead of just printing to the terminal.

Start first window

app.py

import tkinter as tk

# Create the main application window
root = tk.Tk()

# Set window title
root.title("My First Tkinter Window")

# Set window size (width x height)
root.geometry("400x300")

# Start the Tkinter event loop
root.mainloop()

Open a terminal and run:

python app.py

You'll see the first little white window.

Note: I am using Python 3.12 with Tcl-tk@8

Install Tcl-tk if not yet ready on your PC.

This is how you can install it on MacOS (I am using Macbook M1).

brew uninstall tcl-tk
brew install tcl-tk@8

Install Python 3.12

I am using pyenv to manage Python version, you can install it by this command:

brew install pyenv

Now, install Python 3.12 with Tcl-tk

env \
  PATH="/opt/homebrew/opt/tcl-tk@8/bin:$PATH" \
  LDFLAGS="-L/opt/homebrew/opt/tcl-tk@8/lib" \
  CPPFLAGS="-I/opt/homebrew/opt/tcl-tk@8/include" \
  PKG_CONFIG_PATH="/opt/homebrew/opt/tcl-tk@8/lib/pkgconfig" \
  PYTHON_CONFIGURE_OPTS="--with-tcltk-includes='-I/opt/homebrew/opt/tcl-tk@8/include' --with-tcltk-libs='-L/opt/homebrew/opt/tcl-tk@8/lib -ltcl8.6 -ltk8.6'" \
  pyenv install 3.12.8

Add first widget

import tkinter as tk

# Create main window
root = tk.Tk()
root.title("My First Tkinter App")
root.geometry("400x250")

# Add a label
label = tk.Label(root, text="Enter your name:", font=("Arial", 12))
label.pack(pady=10)

# Add a text entry box
entry = tk.Entry(root, font=("Arial", 12))
entry.pack(pady=5)

# Add a button
def say_hello():
    name = entry.get()
    if name.strip():
        output_label.config(text=f"Hello, {name}!")
    else:
        output_label.config(text="Please type your name.")

button = tk.Button(root, text="Submit", font=("Arial", 12), command=say_hello)
button.pack(pady=10)

# Output label
output_label = tk.Label(root, text="", font=("Arial", 12), fg="blue")
output_label.pack(pady=10)

# Run the application
root.mainloop()

And here is our output:

What are tkinter widgets?

In Tkinter, a widget is just a GUI element — the building blocks of your application window.

Think of them as the controls you see in any desktop app:

Labels (text)
Buttons
Text boxes
Checkboxes
Radio buttons
Menus
Frames (containers for grouping stuff)

Basically: everything you place inside your Tkinter window is a widget.

OK, now let's build a very simple profile window for editing a user profile.

Add a profile window

profile.py

import tkinter as tk
from tkinter import ttk

# Create main window
root = tk.Tk()
root.title("Profile Window")
root.geometry("400x500")
root.configure(bg="#f5f5f5")

# ---- Header ----
header = tk.Label(root, text="User Profile", font=("Arial", 18, "bold"), bg="#f5f5f5")
header.pack(pady=15)

# ---- Profile Picture (placeholder as a label) ----
profile_pic = tk.Label(root, text="👤", font=("Arial", 50), bg="#f5f5f5")
profile_pic.pack(pady=10)

# ---- Name ----
name_label = tk.Label(root, text="Name:", font=("Arial", 12), anchor="w", bg="#f5f5f5")
name_label.pack(fill="x", padx=20)

name_entry = tk.Entry(root, font=("Arial", 12))
name_entry.pack(fill="x", padx=20, pady=5)

# ---- Email ----
email_label = tk.Label(root, text="Email:", font=("Arial", 12), anchor="w", bg="#f5f5f5")
email_label.pack(fill="x", padx=20)

email_entry = tk.Entry(root, font=("Arial", 12))
email_entry.pack(fill="x", padx=20, pady=5)

# ---- Bio ----
bio_label = tk.Label(root, text="Bio:", font=("Arial", 12), anchor="w", bg="#f5f5f5")
bio_label.pack(fill="x", padx=20)

bio_text = tk.Text(root, height=5, font=("Arial", 12))
bio_text.pack(fill="x", padx=20, pady=5)

# ---- Save Button ----
def save_profile():
    name = name_entry.get()
    email = email_entry.get()
    bio = bio_text.get("1.0", tk.END).strip()
    print("Profile Saved:")
    print(f"Name: {name}")
    print(f"Email: {email}")
    print(f"Bio: {bio}")
    tk.messagebox.showinfo("Saved", "Profile information saved!")

save_button = ttk.Button(root, text="Save Profile", command=save_profile)
save_button.pack(pady=20)

root.mainloop()

Here we are

What we have done? We have made a profile window with some basic widgets:

A header ("User Profile").
A placeholder “profile picture” (just a Unicode 👤 for now).
Fields for Name, Email, and Bio.
A Save button that prints the data and shows a message box.

Conclusion

For a Python developer who already has a Python-based system and just needs a simple GUI layer on top of it, Tkinter is the ideal choice.

It’s built into Python, so there’s no extra dependency headache.

It integrates seamlessly with existing Python code — you can wrap scripts, functions, or system tools inside a small window with buttons and inputs.

Development is fast and straightforward; a few lines of Tkinter code can turn a command-line script into a usable desktop tool.

What is Async programming

Chanh Le — Thu, 04 Sep 2025 17:49:20 +0000

Synchronous programming

Whenever we make an API call or a database query, we need to wait for the request to travel over the network. This kind of task called I/O bound tasks.

With traditional synchronous programming, when a thread assigned to handle a task, it needs to standby and wait for the request to go over the network and come back.

This is a waste of resources because the thread is blocked and cannot handle any other tasks during the waiting. And with this programming, we usually use a pre-declared thread pool to handle multiple requests at the same time. However, if all threads inside the pool are busy, the system cannot accept any other requests and would drop them. Now, we have problems with scalability. This is where asynchronous (async) programming comes into play.

Asynchronous programming

With async programming, we don't block any threads for waiting I/O tasks. Instead, we have a main thread for accepting requests. These requests would be passed to the system to be run in background. So that, the main thread can continue accepting new requests without any blocking. When a task completed, the system would notify the main thread to continue with next steps.

With this, we don't need to have any thread-pool or so pre-declared. We don't need to concern about how big the pool should be to handle requests more efficiently. And by that, the source code would be much cleaner and easier to maintain or extend.

Example

Synchronous programming:

import time

def fetch_data():
    print("Start fetching")
    time.sleep(2)  # simulates waiting for I/O
    print("Done fetching")
    return {"data": 123}

def main():
    result = fetch_data()
    print(result)

main()

The main thread has to wait 2 seconds before continuing with another request.

Asynchronous programming:

import asyncio

async def fetch_data():
    print("Start fetching")
    await asyncio.sleep(2)  # simulates waiting for I/O
    print("Done fetching")
    return {"data": 123}

async def main():
    result = await fetch_data()
    print(result)

asyncio.run(main())

The main thread will not be blocked for 2 seconds, and can accept other requests immediately.

The await keyword above would tell the system to pause the current task, put it in "pending" state while waiting for the I/O.

By that, the task will be moved out of the main thread stack. So, it can be available for upcoming requests.

Conclusions

Async programming is very helpful, especially when we are about to develop a GUI app like Web app or mobile app, where the main thread needs to be available as much as possible for handling UI rendering and reacting to user's input. All other tasks need to be put into background to avoid blocking the main thread. The main thread in this case sometimes called the UI thread for that reason.
Also, if our application has a lot of I/O tasks, we should consider apply async programming for better scale and easier maintenance.