Vietnam Java User Group - Vietnam JUG, Ho Chi Minh City (2026)

09/08/2026

[English Below]
Hello mọi người!👋 Lần này, hãy cùng bàn về 𝗢𝘂𝘁𝗯𝗼𝘅 𝗣𝗮𝘁𝘁𝗲𝗿𝗻, một giải pháp cực kỳ hiệu quả cho vấn đề 𝗱𝘂𝗮𝗹 𝘄𝗿𝗶𝘁𝗲 trong các 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀. Mình xin giới thiệu bài thuyết trình 𝗜𝗻𝘀 𝗮𝗻𝗱 𝗢𝘂𝘁𝘀 𝗼𝗳 𝘁𝗵𝗲 𝗢𝘂𝘁𝗯𝗼𝘅 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 của 𝗚𝘂𝗻𝗻𝗮𝗿 𝗠𝗼𝗿𝗹𝗶𝗻𝗴 - chuyên gia công nghệ tại 𝗖𝗼𝗻𝗳𝗹𝘂𝗲𝗻𝘁, cựu trưởng dự án 𝗗𝗲𝗯𝗲𝘇𝗶𝘂𝗺 và là tác giả của thử thách 𝗢𝗻𝗲 𝗕𝗶𝗹𝗹𝗶𝗼𝗻 𝗥𝗼𝘄 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲.

Dưới đây là những lý do bạn không nên bỏ lỡ bài thuyết trình này:
🛑 𝗩𝗮̣𝗰𝗵 𝘁𝗿𝗮̂̀𝗻 𝗔𝗻𝘁𝗶-𝗣𝗮𝘁𝘁𝗲𝗿𝗻: Phân tích rõ các rủi ro kiến trúc và lỗi data inconsistency do cách làm dual write thông thường gây ra.
💡 𝗞𝗶𝗲̂́𝗻 𝘁𝗿𝘂́𝗰 𝘁𝗵𝘂̛̣𝗰 𝘁𝗶𝗲̂̃𝗻: Hướng dẫn cách đảm bảo các thay đổi trạng thái mang tính atomic mà không cần dùng đến distributed transactions phức tạp.
🚀 𝗟𝗮̀𝗺 𝗰𝗵𝘂̉ 𝗖𝗗𝗖: Chứng minh vì sao kỹ thuật Log-based 𝗖𝗵𝗮𝗻𝗴𝗲 𝗗𝗮𝘁𝗮 𝗖𝗮𝗽𝘁𝘂𝗿𝗲 (sử dụng Debezium) lại vượt trội hơn hẳn so với kỹ thuật database polling.
🧹 𝗧𝗼̂́𝗶 𝘂̛𝘂 𝘃𝗮̣̂𝗻 𝗵𝗮̀𝗻𝗵: Giới thiệu kỹ thuật "insert-and-immediate-delete" trong cơ sở dữ liệu để ngăn Outbox table bị tăng kích thước.

Nếu bạn là một 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 đang xây dựng các 𝗲𝘃𝗲𝗻𝘁-𝗱𝗿𝗶𝘃𝗲𝗻 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀, việc nắm vững các 𝗸𝗵𝗮́𝗶 𝗻𝗶𝗲̣̂𝗺 𝗖𝗗𝗖 này là bắt buộc để duy trì 𝘁𝗶́𝗻𝗵 𝘁𝗼𝗮̀𝗻 𝘃𝗲̣𝗻 𝗱𝘂̛̃ 𝗹𝗶𝗲̣̂𝘂 cho hệ thống.

(𝘓𝘪𝘯𝘬 𝘣𝘦̂𝘯 𝘥𝘶̛𝘰̛́𝘪 𝘱𝘩𝘢̂̀𝘯 𝘣𝘪̀𝘯𝘩 𝘭𝘶𝘢̣̂𝘯👇)

Team của bạn hiện đang xử lý việc đồng bộ database-to-broker như thế nào? 💬

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 This time, let's talk about the 𝗢𝘂𝘁𝗯𝗼𝘅 𝗣𝗮𝘁𝘁𝗲𝗿𝗻—a compelling solution to the notorious "𝗱𝘂𝗮𝗹 𝘄𝗿𝗶𝘁𝗲" problem in 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀. We are thrilled to feature a brilliant presentation 𝗜𝗻𝘀 𝗮𝗻𝗱 𝗢𝘂𝘁𝘀 𝗼𝗳 𝘁𝗵𝗲 𝗢𝘂𝘁𝗯𝗼𝘅 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 by 𝗚𝘂𝗻𝗻𝗮𝗿 𝗠𝗼𝗿𝗹𝗶𝗻𝗴, a technologist at 𝗖𝗼𝗻𝗳𝗹𝘂𝗲𝗻𝘁, former 𝗗𝗲𝗯𝗲𝘇𝗶𝘂𝗺 lead, and the mind behind the famous 𝗢𝗻𝗲 𝗕𝗶𝗹𝗹𝗶𝗼𝗻 𝗥𝗼𝘄 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲.

Here is why this presentation is highly recommended:
🛑 𝗘𝘅𝗽𝗼𝘀𝗲𝘀 𝘁𝗵𝗲 𝗔𝗻𝘁𝗶-𝗣𝗮𝘁𝘁𝗲𝗿𝗻: Clearly breaks down the architectural risks and data inconsistencies caused by naive dual writes.
💡 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: Explains how to guarantee atomic state changes without relying on heavy distributed transactions.
🚀 𝗖𝗗𝗖 𝗠𝗮𝘀𝘁𝗲𝗿𝘆: Showcases why log-based 𝗖𝗵𝗮𝗻𝗴𝗲 𝗗𝗮𝘁𝗮 𝗖𝗮𝗽𝘁𝘂𝗿𝗲 (Debezium) is fundamentally superior to database polling.
🧹 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆: Reveals a clever "insert-and-immediate-delete" database trick to prevent your Outbox table from bloating.

If you are a 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 building event-driven microservices, mastering these 𝗖𝗗𝗖 𝗰𝗼𝗻𝗰𝗲𝗽𝘁𝘀 is absolutely essential for maintaining rock-solid 𝗱𝗮𝘁𝗮 𝗶𝗻𝘁𝗲𝗴𝗿𝗶𝘁𝘆.

(𝘓𝘪𝘯𝘬 𝘪𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘮𝘦𝘯𝘵 𝘴𝘦𝘤𝘵𝘪𝘰𝘯 𝘣𝘦𝘭𝘰𝘸 👇)

How does your team currently handle database-to-broker synchronization? 💬

Happy learning! 👨‍💻🎉

08/08/2026

[English Below]
Hello mọi người!👋 Tiếp nối bài viết về các tài liệu 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀, mình rất vui được chia sẻ 𝗰𝘂𝗼̂́𝗻 𝘀𝗮́𝗰𝗵 𝘁𝗵𝘂̛́ 𝗵𝗮𝗶 trong chuỗi hai cuốn sách mình đánh giá rất cao: 𝗖𝗹𝗼𝘂𝗱 𝗡𝗮𝘁𝗶𝘃𝗲 𝗦𝗽𝗿𝗶𝗻𝗴 𝗶𝗻 𝗔𝗰𝘁𝗶𝗼𝗻 của tác giả 𝗧𝗵𝗼𝗺𝗮𝘀 𝗩𝗶𝘁𝗮𝗹𝗲. Nếu cuốn sách đầu tiên cung cấp kiến thức nền tảng về 𝗞𝟴𝘀, thì cuốn sách này giúp áp dụng lý thuyết vào code thực tế. Đây là một tài liệu vô cùng thực tiễn và hands-on dành cho các 𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿.

🏗️ 𝗘𝗻𝗱-𝘁𝗼-𝗘𝗻𝗱 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: Bạn sẽ không học qua các ví dụ rời rạc mà sẽ tự xây dựng 𝗺𝗼̣̂𝘁 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 𝗵𝗼𝗮̀𝗻 𝗰𝗵𝗶̉𝗻𝗵, giống với môi trường production ("Polar Bookshop") ngay từ đầu.
🚢 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗥𝗲𝗮𝗱𝘆 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁𝘀: Vượt xa việc Dockerizing đơn giản, sách hướng dẫn chi tiết cách sử dụng 𝗖𝗹𝗼𝘂𝗱 𝗡𝗮𝘁𝗶𝘃𝗲 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀, 𝗞𝘂𝘀𝘁𝗼𝗺𝗶𝘇𝗲, và 𝗚𝗶𝘁𝗢𝗽𝘀 với 𝗔𝗿𝗴𝗼𝗖𝗗.
🛡️ 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗥𝗲𝘀𝗶𝗹𝗶𝗲𝗻𝗰𝗲: Bạn sẽ được hướng dẫn cách implement thực tế 𝗰𝗶𝗿𝗰𝘂𝗶𝘁 𝗯𝗿𝗲𝗮𝗸𝗲𝗿𝘀, 𝗿𝗲𝘁𝗿𝗶𝗲𝘀, và 𝗢𝗔𝘂𝘁𝗵 𝟮.𝟬 với 𝗦𝗽𝗿𝗶𝗻𝗴 𝗖𝗹𝗼𝘂𝗱 𝗚𝗮𝘁𝗲𝘄𝗮𝘆.
🔭 𝗙𝘂𝗹𝗹 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Bạn sẽ học cách thiết lập monitoring và tracing chuyên nghiệp (𝗣𝗿𝗼𝗺𝗲𝘁𝗵𝗲𝘂𝘀, 𝗚𝗿𝗮𝗳𝗮𝗻𝗮, 𝗢𝗽𝗲𝗻𝗧𝗲𝗹𝗲𝗺𝗲𝘁𝗿𝘆).

Nếu bạn là một 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 trình độ 𝗶𝗻𝘁𝗲𝗿𝗺𝗲𝗱𝗶𝗮𝘁𝗲-𝘁𝗼-𝗮𝗱𝘃𝗮𝗻𝗰𝗲𝗱, đây là tài liệu hướng dẫn chi tiết để đưa application của bạn từ 𝗺𝗼̂𝗶 𝘁𝗿𝘂̛𝗼̛̀𝗻𝗴 𝗹𝗼𝗰𝗮𝗹 lên các 𝗰𝗹𝗼𝘂𝗱 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 đạt chuẩn 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗴𝗿𝗮𝗱𝗲 và 𝗳𝗮𝘂𝗹𝘁-𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝘁.

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 Following up on my top 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 resources, I’m excited to share the 𝘀𝗲𝗰𝗼𝗻𝗱 𝗺𝘂𝘀𝘁-𝗿𝗲𝗮𝗱 in my two-part series: 𝗖𝗹𝗼𝘂𝗱 𝗡𝗮𝘁𝗶𝘃𝗲 𝗦𝗽𝗿𝗶𝗻𝗴 𝗶𝗻 𝗔𝗰𝘁𝗶𝗼𝗻 by 𝗧𝗵𝗼𝗺𝗮𝘀 𝗩𝗶𝘁𝗮𝗹𝗲. While my first recommendation laid the 𝗞𝟴𝘀 foundation, this book bridges the gap between theory and actual code. It is an intensely practical, hands-on masterclass for 𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀.

🏗️ 𝗘𝗻𝗱-𝘁𝗼-𝗘𝗻𝗱 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: You skip the disjointed examples and build a 𝗰𝗼𝗺𝗽𝗿𝗲𝗵𝗲𝗻𝘀𝗶𝘃𝗲, 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗹𝗶𝗸𝗲 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 ("Polar Bookshop") from scratch.
🚢 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗥𝗲𝗮𝗱𝘆 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁𝘀: It goes far beyond simple Dockerizing to teach 𝗖𝗹𝗼𝘂𝗱 𝗡𝗮𝘁𝗶𝘃𝗲 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀, 𝗞𝘂𝘀𝘁𝗼𝗺𝗶𝘇𝗲, and 𝗚𝗶𝘁𝗢𝗽𝘀 with 𝗔𝗿𝗴𝗼𝗖𝗗.
🛡️ 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗥𝗲𝘀𝗶𝗹𝗶𝗲𝗻𝗰𝗲: You get practical implementation of 𝗰𝗶𝗿𝗰𝘂𝗶𝘁 𝗯𝗿𝗲𝗮𝗸𝗲𝗿𝘀, 𝗿𝗲𝘁𝗿𝗶𝗲𝘀, and 𝗢𝗔𝘂𝘁𝗵 𝟮.𝟬 with 𝗦𝗽𝗿𝗶𝗻𝗴 𝗖𝗹𝗼𝘂𝗱 𝗚𝗮𝘁𝗲𝘄𝗮𝘆.
🔭 𝗙𝘂𝗹𝗹 𝗢𝗯𝘀𝗲𝗿𝘃𝗮𝗯𝗶𝗹𝗶𝘁𝘆: You actually learn how to set up professional monitoring and tracing (𝗣𝗿𝗼𝗺𝗲𝘁𝗵𝗲𝘂𝘀, 𝗚𝗿𝗮𝗳𝗮𝗻𝗮, 𝗢𝗽𝗲𝗻𝗧𝗲𝗹𝗲𝗺𝗲𝘁𝗿𝘆).

If you are an 𝗶𝗻𝘁𝗲𝗿𝗺𝗲𝗱𝗶𝗮𝘁𝗲-𝘁𝗼-𝗮𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿, this is the definitive guide to taking your applications from 𝗹𝗼𝗰𝗮𝗹 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁𝘀 to 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗴𝗿𝗮𝗱𝗲, 𝗳𝗮𝘂𝗹𝘁-𝘁𝗼𝗹𝗲𝗿𝗮𝗻𝘁 𝗰𝗹𝗼𝘂𝗱 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲𝘀.

Happy learning! 👨‍💻🎉

07/08/2026

[English Below]
Hello mọi người!👋 Tiếp nối chuỗi bài viết gần đây về việc 𝗗𝗼𝗰𝗸𝗲𝗿𝗶𝘇𝗶𝗻𝗴 𝗝𝗮𝘃𝗮 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻, bước tiếp theo chắc chắn sẽ là 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁. Hôm nay, chúng ta hãy cùng triển khai chúng lên 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 nhé!

Để hỗ trợ quá trình này, mình muốn giới thiệu cuốn sách 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 𝗶𝗻 𝗔𝗰𝘁𝗶𝗼𝗻 (𝟮𝗻𝗱 𝗘𝗱𝗶𝘁𝗶𝗼𝗻) của 𝗠𝗮𝗿𝗸𝗼 𝗟𝘂𝗸𝘀̌𝗮. Thực sự, trong tất cả các tài liệu kỹ thuật mình từng đọc, đây là 𝗺𝗼̣̂𝘁 𝘁𝗿𝗼𝗻𝗴 𝗵𝗮𝗶 𝗰𝘂𝗼̂́𝗻 𝘀𝗮́𝗰𝗵 duy nhất về 𝗞𝟴𝘀 khiến mình bị thu hút ngay từ trang đầu tiên.

Dưới đây là những điểm nổi bật nhất của cuốn sách:
🧠 𝗗𝗲𝗲𝗽 𝗠𝗲𝗻𝘁𝗮𝗹 𝗠𝗼𝗱𝗲𝗹𝘀: Sách không chỉ dừng lại ở các lệnh 𝘬𝘶𝘣𝘦𝘤𝘵𝘭 đơn giản, mà còn dùng các sơ đồ rõ ràng để giải thích chính xác cách Control Plane và worker nodes tương tác với nhau.
🏗️ 𝗣𝗲𝗿𝗳𝗲𝗰𝘁 𝗣𝗮𝗰𝗶𝗻𝗴: Nội dung chuyển tiếp mượt mà từ các khái niệm container cơ bản đến deployment và scaling nâng cao.
🛠️ 𝗛𝗮𝗻𝗱𝘀-𝗼𝗻 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹𝗶𝘁𝘆: Các ví dụ rất dễ hiểu và có thể dễ dàng chạy locally, giúp bạn áp dụng ngay các khái niệm infrastructure phức tạp.

Đối với các 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀, cuốn sách này mang lại giá trị rất lớn. Nó giải thích chi tiết cách chuyển đổi từ các dependency nặng của 𝗦𝗽𝗿𝗶𝗻𝗴 𝗖𝗹𝗼𝘂𝗱 (như 𝗘𝘂𝗿𝗲𝗸𝗮 - 𝘀𝗲𝗿𝘃𝗶𝗰𝗲 𝗱𝗶𝘀𝗰𝗼𝘃𝗲𝗿𝘆, 𝗖𝗼𝗻𝗳𝗶𝗴 - 𝗰𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻) sang các 𝗻𝗮𝘁𝗶𝘃𝗲 𝗞𝟴𝘀 𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀, giúp bạn tự tin quản lý các 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀 của mình.

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 Following our recent series on 𝗗𝗼𝗰𝗸𝗲𝗿𝗶𝘇𝗶𝗻𝗴 𝗝𝗮𝘃𝗮 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻, the next logical step is 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁. Let's orchestrate them with 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 today!

To guide us, I want to introduce 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀 𝗶𝗻 𝗔𝗰𝘁𝗶𝗼𝗻 (𝟮𝗻𝗱 𝗘𝗱𝗶𝘁𝗶𝗼𝗻) by 𝗠𝗮𝗿𝗸𝗼 𝗟𝘂𝗸𝘀̌𝗮. Honestly, out of all the technical literature I've consumed, this is 𝗼𝗻𝗲 𝗼𝗳 𝗼𝗻𝗹𝘆 𝘁𝘄𝗼 𝗯𝗼𝗼𝗸𝘀 about 𝗞𝟴𝘀 I’ve read where I was instantly hooked from page one.

Here is why it stands out:
🧠 𝗗𝗲𝗲𝗽 𝗠𝗲𝗻𝘁𝗮𝗹 𝗠𝗼𝗱𝗲𝗹𝘀: It goes beyond simple kubectl commands, using clear diagrams to explain exactly how the Control Plane and worker nodes interact.
🏗️ 𝗣𝗲𝗿𝗳𝗲𝗰𝘁 𝗣𝗮𝗰𝗶𝗻𝗴: It seamlessly transitions from basic container concepts to advanced deployments and scaling.
🛠️ 𝗛𝗮𝗻𝗱𝘀-𝗼𝗻 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹𝗶𝘁𝘆: The examples are straightforward and easy to run locally, making complex infrastructure concepts immediately actionable.

For 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀, this book is a game-changer. It perfectly explains how to shift from heavy 𝗦𝗽𝗿𝗶𝗻𝗴 𝗖𝗹𝗼𝘂𝗱 dependencies (like 𝗘𝘂𝗿𝗲𝗸𝗮 - 𝘀𝗲𝗿𝘃𝗶𝗰𝗲 𝗱𝗶𝘀𝗰𝗼𝘃𝗲𝗿𝘆, 𝗖𝗼𝗻𝗳𝗶𝗴 - 𝗰𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻) to 𝗻𝗮𝘁𝗶𝘃𝗲 𝗞𝟴𝘀 𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀, empowering you to confidently manage your 𝗺𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀.

Happy learning! 👨‍💻🎉

06/08/2026

[English Below]
Hello mọi người!👋 Tiếp nối bài tổng quan gần đây của chúng ta về các 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝘁𝗼𝗼𝗹𝘀 𝗵𝗶𝗲̣̂𝗻 𝐝𝗮̣𝗶 như 𝗚𝗼𝗼𝗴𝗹𝗲 𝗝𝗶𝗯 và 𝗣𝗮𝗸𝗲𝘁𝗼 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀, lần này hãy cùng phân tích chi tiết về 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀. Với việc được 𝘁𝗶́𝗰𝗵 𝗵𝗼̛̣𝗽 𝗻𝗮𝘁𝗶𝘃𝗲 vào hệ sinh thái 𝗦𝗽𝗿𝗶𝗻𝗴, đây là một lựa chọn mang tính thực tiễn cao cho các 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 hàng ngày của chúng ta.

Bài phân tích chi tiết này sẽ làm rõ lý do tại sao bạn nên cân nhắc việc ngừng duy trì các 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀 theo cách thủ công. Những điểm chính bao gồm:
🚀 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗱 𝗗𝗲𝗳𝗮𝘂𝗹𝘁𝘀: Tự động cấu hình các giới hạn bộ nhớ JVM và các runtime flags để ngăn chặn lỗi out-of-memory mà 𝗸𝗵𝗼̂𝗻𝗴 𝗰𝗮̂̀𝗻 𝘃𝗶𝗲̂́𝘁 𝗯𝗮̂́𝘁 𝗸𝘆̀ 𝗱𝗼̀𝗻𝗴 𝗗𝗼𝗰𝗸𝗲𝗿 𝗰𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻 𝗻𝗮̀𝗼.
🛡️ 𝗢𝘂𝘁-𝗼𝗳-𝘁𝗵𝗲-𝗕𝗼𝘅 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: Tạo ngay một 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗕𝗶𝗹𝗹 𝗼𝗳 𝗠𝗮𝘁𝗲𝗿𝗶𝗮𝗹𝘀 (𝗦𝗕𝗢𝗠) cho image của bạn, giúp tăng cường compliance về bảo mật một cách dễ dàng.
⚡ 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻𝘀: Mở khóa các tính năng nâng cao như 𝗖𝗹𝗮𝘀𝘀 𝗗𝗮𝘁𝗮 𝗦𝗵𝗮𝗿𝗶𝗻𝗴 (𝗖𝗗𝗦) - nay đổi tên là 𝗔𝗢𝗧 𝗖𝗮𝗰𝗵𝗲 trong 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗟𝗲𝘆𝗱𝗲𝗻, trong quá trình build để giảm một nửa thời gian startup ứng dụng.

Video này cung cấp góc nhìn 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 ở mức 𝗵𝗶𝗴𝗵-𝗹𝗲𝘃𝗲𝗹, do đó có thể 𝗸𝗵𝗼̂𝗻𝗴 𝗵𝗼𝗮̀𝗻 𝘁𝗼𝗮̀𝗻 𝗯𝗲𝗴𝗶𝗻𝗻𝗲𝗿-𝗳𝗿𝗶𝗲𝗻𝗱𝗹𝘆. Tuy nhiên, nếu bạn mới làm quen với 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀 nhưng đang sử dụng 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁, bạn không cần phải là chuyên gia để bắt đầu. Chỉ cần chạy lệnh ./𝗺𝘃𝗻𝘄 𝘀𝗽𝗿𝗶𝗻𝗴-𝗯𝗼𝗼𝘁:𝗯𝘂𝗶𝗹𝗱-𝗶𝗺𝗮𝗴𝗲 trong terminal để 𝗦𝗽𝗿𝗶𝗻𝗴 tự động thực hiện quá trình build!

(𝘓𝘪𝘯𝘬 𝘣𝘦̂𝘯 𝘥𝘶̛𝘰̛́𝘪 𝘱𝘩𝘢̂̀𝘯 𝘣𝘪̀𝘯𝘩 𝘭𝘶𝘢̣̂𝘯👇)

Bạn đã sẵn sàng để tối ưu hóa các 𝗝𝗮𝘃𝗮 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀 của mình chưa? 💬

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 Following our recent overview of 𝗺𝗼𝗱𝗲𝗿𝗻 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 𝘁𝗼𝗼𝗹𝘀 like 𝗚𝗼𝗼𝗴𝗹𝗲 𝗝𝗶𝗯 and 𝗣𝗮𝗸𝗲𝘁𝗼 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀, let’s dive deeper into 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀. Given its 𝗻𝗮𝘁𝗶𝘃𝗲 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗶𝗼𝗻 with the 𝗦𝗽𝗿𝗶𝗻𝗴 ecosystem, it's a highly practical choice for our daily 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀.

This deep dive highlights why you might want to move away from manually maintaining 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀. Key takeaways include:
🚀 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗱 𝗗𝗲𝗳𝗮𝘂𝗹𝘁𝘀: Automatically configures JVM memory limits and runtime flags to prevent out-of-memory errors 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝘄𝗿𝗶𝘁𝗶𝗻𝗴 𝗮 𝘀𝗶𝗻𝗴𝗹𝗲 𝗹𝗶𝗻𝗲 𝗼𝗳 𝗗𝗼𝗰𝗸𝗲𝗿 𝗰𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻.
🛡️ 𝗢𝘂𝘁-𝗼𝗳-𝘁𝗵𝗲-𝗕𝗼𝘅 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: Instantly generates a 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗕𝗶𝗹𝗹 𝗼𝗳 𝗠𝗮𝘁𝗲𝗿𝗶𝗮𝗹𝘀 (𝗦𝗕𝗢𝗠) for your image, enhancing your security compliance effortlessly.
⚡ 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻𝘀: Unlocks advanced features like 𝗔𝗢𝗧 𝗖𝗮𝗰𝗵𝗲 in 𝗣𝗿𝗼𝗷𝗲𝗰𝘁 𝗟𝗲𝘆𝗱𝗲𝗻 during the build to cut your application startup times in half.

This video offers a 𝗵𝗶𝗴𝗵-𝗹𝗲𝘃𝗲𝗹 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗮𝗹 𝘃𝗶𝗲𝘄, which might 𝗻𝗼𝘁 𝗯𝗲 𝗲𝗻𝘁𝗶𝗿𝗲𝗹𝘆 𝗯𝗲𝗴𝗶𝗻𝗻𝗲𝗿-𝗳𝗿𝗶𝗲𝗻𝗱𝗹𝘆. However, if you are new to 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀 but already using 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁, you don't need to be an expert to get started. Simply run ./𝗺𝘃𝗻𝘄 𝘀𝗽𝗿𝗶𝗻𝗴-𝗯𝗼𝗼𝘁:𝗯𝘂𝗶𝗹𝗱-𝗶𝗺𝗮𝗴𝗲 in your terminal to let 𝗦𝗽𝗿𝗶𝗻𝗴 do the heavy lifting!

(𝘓𝘪𝘯𝘬 𝘪𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘮𝘦𝘯𝘵 𝘴𝘦𝘤𝘵𝘪𝘰𝘯 𝘣𝘦𝘭𝘰𝘸 👇)

Ready to optimize your 𝗝𝗮𝘃𝗮 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝘀? 💬

Happy learning! 👨‍💻🎉

05/08/2026

[English Below]
Hello mọi người!👋 Bạn vẫn đang sử dụng các 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀 cơ bản để 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝗶𝘇𝗲 các ứng dụng 𝗝𝗮𝘃𝗮 của mình? Đã đến lúc cần cập nhật phương pháp mới.

Trong bài talk này, chúng ta sẽ tìm hiểu chi tiết về quá trình phát triển của 𝗝𝗮𝘃𝗮 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝗶𝘇𝗮𝘁𝗶𝗼𝗻 để giúp bạn build các images được tối ưu hóa. Dưới đây là những lợi ích đáng chú ý nhất của video:

🚀 𝗙𝗮𝘀𝘁𝗲𝗿 𝗕𝘂𝗶𝗹𝗱𝘀: Nắm vững multi-stage builds và BuildKit cache mounts để giảm thiểu đáng kể thời gian build Maven/Gradle.
📦 𝗠𝗶𝗰𝗿𝗼-𝗦𝗶𝘇𝗲𝗱 𝗜𝗺𝗮𝗴𝗲𝘀: Tìm hiểu cách sử dụng 𝗟𝗮𝘆𝗲𝗿𝗲𝗱 𝗝𝗔𝗥𝘀 và Jlink để loại bỏ các phần không cần thiết và tạo ra các runtimes có kích thước rất nhỏ.
🛡️ 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗲𝗱 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: Khám phá các giải pháp hiện đại như 𝗚𝗼𝗼𝗴𝗹𝗲 𝗝𝗶𝗯 và 𝗖𝗹𝗼𝘂𝗱 𝗡𝗮𝘁𝗶𝘃𝗲 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀 (𝗣𝗮𝗸𝗲𝘁𝗼) cho phép cập nhật bảo mật đồng loạt ngay lập tức mà 𝗸𝗵𝗼̂𝗻𝗴 𝗰𝗮̂̀𝗻 𝘃𝗶𝗲̂́𝘁 𝗯𝗮̂́𝘁 𝗸𝘆̀ 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲 𝗻𝗮̀𝗼.

Đối với các 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀, bài nói chuyện này cung cấp các hướng dẫn thực tế để 𝗰𝗵𝘂𝗮̂̉𝗻 𝗵𝗼́𝗮 𝗖𝗜/𝗖𝗗 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀, tối ưu hóa việc sử dụng tài nguyên và tránh phải bảo trì các 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀 phức tạp được viết thủ công.

(𝘓𝘪𝘯𝘬 𝘣𝘦̂𝘯 𝘥𝘶̛𝘰̛́𝘪 𝘱𝘩𝘢̂̀𝘯 𝘣𝘪̀𝘯𝘩 𝘭𝘶𝘢̣̂𝘯👇)

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 Are you still relying on basic 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀 to 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝗶𝘇𝗲 your Java applications? It might be time for a strategic upgrade.

In this fantastic presentation, we dive deep into the evolution of 𝗝𝗮𝘃𝗮 𝗰𝗼𝗻𝘁𝗮𝗶𝗻𝗲𝗿𝗶𝘇𝗮𝘁𝗶𝗼 to help you build highly optimized images. Here is what makes this video a must-watch:

🚀 𝗙𝗮𝘀𝘁𝗲𝗿 𝗕𝘂𝗶𝗹𝗱𝘀: Master multi-stage builds and BuildKit cache mounts to drastically slash your Maven/Gradle build times.
📦 𝗠𝗶𝗰𝗿𝗼-𝗦𝗶𝘇𝗲𝗱 𝗜𝗺𝗮𝗴𝗲𝘀: Learn how to utilize 𝗟𝗮𝘆𝗲𝗿𝗲𝗱 𝗝𝗔𝗥𝘀 and Jlink to strip away bloat and create incredibly small runtimes.
🛡️ 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗲𝗱 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: Discover modern alternatives like 𝗚𝗼𝗼𝗴𝗹𝗲 𝗝𝗶𝗯 and 𝗖𝗹𝗼𝘂𝗱 𝗡𝗮𝘁𝗶𝘃𝗲 𝗕𝘂𝗶𝗹𝗱𝗽𝗮𝗰𝗸𝘀 (𝗣𝗮𝗸𝗲𝘁𝗼) that allow for instant fleet-wide security patching 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝘄𝗿𝗶𝘁𝗶𝗻𝗴 𝗮 𝘀𝗶𝗻𝗴𝗹𝗲 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲.

For 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀, this talk is a practical roadmap to standardizing your 𝗖𝗜/𝗖𝗗 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀, optimizing resource usage, and avoiding the maintenance nightmare of complex, hand-crafted 𝗗𝗼𝗰𝗸𝗲𝗿𝗳𝗶𝗹𝗲𝘀.

(𝘓𝘪𝘯𝘬 𝘪𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘮𝘦𝘯𝘵 𝘴𝘦𝘤𝘵𝘪𝘰𝘯 𝘣𝘦𝘭𝘰𝘸 👇)

Happy learning! 👨‍💻🎉

04/08/2026

[English Below]
Hello mọi người!👋 𝗝𝗮𝘃𝗮 đang vận hành phần lớn thế giới enterprise, nhưng chỉ chiếm một tỷ lệ rất nhỏ trong các 𝗔𝗪𝗦 𝗟𝗮𝗺𝗯𝗱𝗮 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 — 𝗣𝘆𝘁𝗵𝗼𝗻 và 𝗡𝗼𝗱𝗲.𝗷𝘀 gần như chiếm trọn phần còn lại. Trong bài talk này của 𝗜𝗻𝗳𝗼𝗤, 𝗔𝗪𝗦 𝗛𝗲𝗿𝗼 𝗩𝗮𝗱𝘆𝗺 𝗞𝗮𝘇𝘂𝗹𝗸𝗶𝗻 đo đạc chính xác lý do tại sao, và khoảng cách này có thể được thu hẹp đến đâu.

Điểm khởi đầu: một function 𝟭𝟰 𝗠𝗕 chạy trên 𝟭 𝗚𝗕 memory phản hồi trong 𝟳 𝗺𝘀 khi warm, nhưng cần đến 𝟯.𝟮 𝗴𝗶𝗮̂𝘆 khi 𝗰𝗼𝗹𝗱 𝘀𝘁𝗮𝗿𝘁. Có hai công nghệ giải quyết vấn đề này: 𝗔𝗪𝗦 𝗟𝗮𝗺𝗯𝗱𝗮 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 (snapshot và restore microVM đã được khởi tạo) và 𝗚𝗿𝗮𝗮𝗹𝗩𝗠 𝗡𝗮𝘁𝗶𝘃𝗲 𝗜𝗺𝗮𝗴𝗲 (ahead-of-time compilation).

Dưới đây là các kết quả đo được:
📸 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 𝗖𝗵𝗶̉ 𝗟𝗮̀ 𝗠𝗼̣̂𝘁 𝗙𝗹𝗮𝗴: Bật tính năng này giúp giảm 𝗣𝟵𝟬 cold start từ 3.2s xuống còn khoảng 2s chỉ với một dòng infrastructure code.
🎯 𝗣𝗿𝗶𝗺𝗶𝗻𝗴 𝗡𝗵𝗮̂𝗻 𝗕𝗼̣̂𝗶 𝗛𝗶𝗲̣̂𝘂 𝗤𝘂𝗮̉: Implement 𝗯𝗲𝗳𝗼𝗿𝗲𝗖𝗵𝗲𝗰𝗸𝗽𝗼𝗶𝗻𝘁() từ 𝗼𝗿𝗴.𝗰𝗿𝗮𝗰 để pre-initialize Apache HTTP client và Jackson 𝗢𝗯𝗷𝗲𝗰𝘁𝗠𝗮𝗽𝗽𝗲𝗿 sẽ đẩy P90 xuống dưới 1 giây.
📦 𝗞𝗶́𝗰𝗵 𝗧𝗵𝘂̛𝗼̛́𝗰 𝗔𝗿𝘁𝗶𝗳𝗮𝗰𝘁 𝗟𝗮̀ 𝗠𝗼̣̂𝘁 𝗖𝗵𝗶 𝗣𝗵𝗶́ 𝗧𝗿𝘂̛̣𝗰 𝗧𝗶𝗲̂́𝗽: Các bản deploy 130 KB, 14 MB và 50 MB tạo ra những cold start khác biệt rõ rệt, ngay cả khi đã áp dụng SnapStart và priming.
⚖️ 𝗠𝗮𝗻𝗮𝗴𝗲𝗱 𝘃𝘀 𝗦𝗲𝗹𝗳-𝗕𝘂𝗶𝗹𝘁: 𝗚𝗿𝗮𝗮𝗹𝗩𝗠 cho các con số tốt hơn, nhưng 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 không đòi hỏi build pipeline, không cần reflection configuration, và không gặp các lỗi class-not-found lúc runtime.

Đối với các 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝘁𝗲𝗮𝗺𝘀, điều này thay đổi hoàn toàn bài toán: một 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗟𝗮𝗺𝗯𝗱𝗮 không còn phải chấp nhận cold start 3 giây, và việc kiểm soát dependencies giờ đây quan trọng hơn rất nhiều so với thời chạy trên Tomcat.

Bạn sẽ chọn giải pháp nào trước — 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 hay 𝗚𝗿𝗮𝗮𝗹𝗩𝗠? Hãy chia sẻ các con số từ production của bạn dưới phần bình luận nhé! 💬

(𝘓𝘪𝘯𝘬 𝘣𝘦̂𝘯 𝘥𝘶̛𝘰̛́𝘪 𝘱𝘩𝘢̂̀𝘯 𝘣𝘪̀𝘯𝘩 𝘭𝘶𝘢̣̂𝘯👇)

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 𝗝𝗮𝘃𝗮 runs most of the enterprise world, yet it accounts for only a single-digit percentage of 𝗔𝗪𝗦 𝗟𝗮𝗺𝗯𝗱𝗮 functions — 𝗣𝘆𝘁𝗵𝗼𝗻 and 𝗡𝗼𝗱𝗲.𝗷𝘀 take nearly everything else. In this 𝗜𝗻𝗳𝗼𝗤 talk, 𝗔𝗪𝗦 𝗛𝗲𝗿𝗼 𝗩𝗮𝗱𝘆𝗺 𝗞𝗮𝘇𝘂𝗹𝗸𝗶𝗻 measures exactly why, and how far the gap can be closed.

The baseline: a 𝟭𝟰 𝗠𝗕 function on 𝟭 𝗚𝗕 of memory answers in 𝟳 𝗺𝘀 warm, but needs 𝟯.𝟮 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 on a 𝗰𝗼𝗹𝗱 𝘀𝘁𝗮𝗿𝘁. Two technologies address this: 𝗔𝗪𝗦 𝗟𝗮𝗺𝗯𝗱𝗮 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 (snapshot and restore of the initialized microVM) and 𝗚𝗿𝗮𝗮𝗹𝗩𝗠 𝗡𝗮𝘁𝗶𝘃𝗲 𝗜𝗺𝗮𝗴𝗲 (ahead-of-time compilation).

The measured findings:
📸 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 𝗜𝘀 𝗢𝗻𝗲 𝗙𝗹𝗮𝗴: Enabling it drops the 𝗣𝟵𝟬 cold start from 3.2s to roughly 2s with one line of infrastructure code.
🎯 𝗣𝗿𝗶𝗺𝗶𝗻𝗴 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗶𝗲𝘀 𝘁𝗵𝗲 𝗚𝗮𝗶𝗻: Implementing 𝗯𝗲𝗳𝗼𝗿𝗲𝗖𝗵𝗲𝗰𝗸𝗽𝗼𝗶𝗻𝘁() from 𝗼𝗿𝗴.𝗰𝗿𝗮𝗰 to pre-initialize the Apache HTTP client and Jackson 𝗢𝗯𝗷𝗲𝗰𝘁𝗠𝗮𝗽𝗽𝗲𝗿 pushes P90 under 1 second.
📦 𝗔𝗿𝘁𝗶𝗳𝗮𝗰𝘁 𝗦𝗶𝘇𝗲 𝗜𝘀 𝗮 𝗗𝗶𝗿𝗲𝗰𝘁 𝗖𝗼𝘀𝘁: 130 KB, 14 MB and 50 MB deployments produce measurably different cold starts, even with SnapStart and priming applied.
⚖️ 𝗠𝗮𝗻𝗮𝗴𝗲𝗱 𝘃𝘀 𝗦𝗲𝗹𝗳-𝗕𝘂𝗶𝗹𝘁: 𝗚𝗿𝗮𝗮𝗹𝗩𝗠 delivers lower numbers, but 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 demands no build pipeline, no reflection configuration, and no runtime class-not-found failures.

For 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 𝘁𝗲𝗮𝗺𝘀, this changes the calculation: a 𝗦𝗽𝗿𝗶𝗻𝗴 𝗕𝗼𝗼𝘁 𝗟𝗮𝗺𝗯𝗱𝗮 no longer has to accept 3-second cold starts, and dependency hygiene now matters far more than it ever did on Tomcat.

Which would you reach for first — 𝗦𝗻𝗮𝗽𝗦𝘁𝗮𝗿𝘁 or 𝗚𝗿𝗮𝗮𝗹𝗩𝗠? Share your production numbers below! 💬

(𝘓𝘪𝘯𝘬 𝘪𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘮𝘦𝘯𝘵 𝘴𝘦𝘤𝘵𝘪𝘰𝘯 𝘣𝘦𝘭𝘰𝘸 👇)

Happy learning! 👨‍💻🎉

03/08/2026

[English Below]
Hello mọi người!👋 Hầu hết các sự cố bộ nhớ trong 𝗝𝗮𝘃𝗮 không bắt đầu từ một 𝗺𝗲𝗺𝗼𝗿𝘆 𝗹𝗲𝗮𝗸 — chúng bắt đầu từ một giá trị mặc định mà không ai chủ động lựa chọn. Trong session tại 𝗝𝗮𝘃𝗮𝗢𝗻𝗲 này, 𝗝𝗮𝘃𝗮 𝗖𝗵𝗮𝗺𝗽𝗶𝗼𝗻 𝗔𝗻𝗱𝗿𝘇𝗲𝗷 "𝗔𝘅𝗲" 𝗚𝗿𝘇𝗲𝘀𝗶𝗸 sẽ giải thích điều gì thực sự xảy ra với từng byte bên trong 𝗝𝗩𝗠, và tại sao một container 2 GB vẫn có thể bị 𝗢𝗢𝗠-𝗸𝗶𝗹𝗹𝗲𝗱 dù đã cấu hình 𝗵𝗲𝗮𝗽 2 GB.

Bài talk phân tích chi tiết mọi vùng nhớ mà một 𝗝𝗮𝘃𝗮 𝗽𝗿𝗼𝗰𝗲𝘀𝘀 phải trả giá — 𝗵𝗲𝗮𝗽, 𝗺𝗲𝘁𝗮𝘀𝗽𝗮𝗰𝗲, 𝗰𝗼𝗱𝗲 𝗰𝗮𝗰𝗵𝗲, 𝗼𝗳𝗳-𝗵𝗲𝗮𝗽 𝗯𝘂𝗳𝗳𝗲𝗿𝘀, 𝘁𝗵𝗿𝗲𝗮𝗱 𝘀𝘁𝗮𝗰𝗸𝘀 và 𝗼𝗯𝗷𝗲𝗰𝘁 𝗵𝗲𝗮𝗱𝗲𝗿𝘀 — cùng các flags giúp kiểm soát chúng.

Dưới đây là những điểm nổi bật:
🎯 𝗞𝗻𝗼𝘄 𝗬𝗼𝘂𝗿 𝗗𝗲𝗳𝗮𝘂𝗹𝘁𝘀: Trên một máy "server", 𝗝𝗩𝗠 mặc định chỉ lấy khoảng 𝟮𝟱% RAM cho 𝗵𝗲𝗮𝗽, nên việc thiết lập -𝗫𝗺𝘅 một cách tường minh là quyết định mang lại hiệu quả cao nhất.
🧩 𝗠𝗼𝗿𝗲 𝗧𝗵𝗮𝗻 𝘁𝗵𝗲 𝗛𝗲𝗮𝗽: 𝗠𝗲𝘁𝗮𝘀𝗽𝗮𝗰𝗲 (không giới hạn mặc định), 𝗖𝗼𝗱𝗲 𝗖𝗮𝗰𝗵𝗲 và 𝗢𝗳𝗳-𝗛𝗲𝗮𝗽 byte buffers đều tiêu thụ bộ nhớ nằm ngoài -𝗫𝗺𝘅, đó là lý do container limits và heap size phải được cân đối với nhau.
🪶 𝗟𝗶𝗴𝗵𝘁𝗲𝗿 𝗢𝗯𝗷𝗲𝗰𝘁 𝗛𝗲𝗮𝗱𝗲𝗿𝘀: -𝗫𝗫:+𝗨𝘀𝗲𝗖𝗼𝗺𝗽𝗮𝗰𝘁𝗢𝗯𝗷𝗲𝗰𝘁𝗛𝗲𝗮𝗱𝗲𝗿𝘀 trong 𝗝𝗗𝗞 𝟮𝟰/𝟮𝟱 giúp giảm overhead trên mỗi object và đã mang lại mức cải thiện throughput đo lường được ở production.
🔍 𝗙𝗶𝗻𝗱 𝘁𝗵𝗲 𝗥𝗲𝗮𝗹 𝗖𝘂𝗹𝗽𝗿𝗶𝘁: Các 𝗦𝘁𝗿𝗶𝗻𝗴 trùng lặp và các boxed 𝘄𝗿𝗮𝗽𝗽𝗲𝗿 𝘁𝘆𝗽𝗲𝘀 chiếm phần lớn dung lượng trong hầu hết các heap, và các công cụ như 𝗘𝗰𝗹𝗶𝗽𝘀𝗲 𝗠𝗔𝗧 và 𝗡𝗮𝘁𝗶𝘃𝗲 𝗠𝗲𝗺𝗼𝗿𝘆 𝗧𝗿𝗮𝗰𝗸𝗶𝗻𝗴 sẽ chỉ cho bạn chính xác vị trí.

Đối với các đội ngũ 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 chạy trên 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀, đây chính là sự khác biệt giữa một service được right-size gọn gàng và một service đột nhiên "chết" dưới tải mà không để lại stack trace nào để giải thích.

𝗝𝗩𝗠 flag nào đã giúp bạn thoát khỏi nhiều rắc rối nhất? Hãy chia sẻ ở phần bình luận nhé! 💬

(𝘓𝘪𝘯𝘬 𝘣𝘦̂𝘯 𝘥𝘶̛𝘰̛́𝘪 𝘱𝘩𝘢̂̀𝘯 𝘣𝘪̀𝘯𝘩 𝘭𝘶𝘢̣̂𝘯👇)

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 Most 𝗝𝗮𝘃𝗮 memory incidents do not start with a 𝗺𝗲𝗺𝗼𝗿𝘆 𝗹𝗲𝗮𝗸 — they start with a default value nobody chose on purpose. In this 𝗝𝗮𝘃𝗮𝗢𝗻𝗲 session, 𝗝𝗮𝘃𝗮 𝗖𝗵𝗮𝗺𝗽𝗶𝗼𝗻 𝗔𝗻𝗱𝗿𝘇𝗲𝗷 "𝗔𝘅𝗲" 𝗚𝗿𝘇𝗲𝘀𝗶𝗸 explains what really happens to your bytes inside the 𝗝𝗩𝗠, and why a 2 GB container can still get 𝗢𝗢𝗠-𝗸𝗶𝗹𝗹𝗲𝗱 with a 2 GB 𝗵𝗲𝗮𝗽.

The talk maps every region a 𝗝𝗮𝘃𝗮 𝗽𝗿𝗼𝗰𝗲𝘀𝘀 pays for — 𝗵𝗲𝗮𝗽, 𝗺𝗲𝘁𝗮𝘀𝗽𝗮𝗰𝗲, 𝗰𝗼𝗱𝗲 𝗰𝗮𝗰𝗵𝗲, 𝗼𝗳𝗳-𝗵𝗲𝗮𝗽 𝗯𝘂𝗳𝗳𝗲𝗿𝘀, 𝘁𝗵𝗿𝗲𝗮𝗱 𝘀𝘁𝗮𝗰𝗸𝘀, and 𝗼𝗯𝗷𝗲𝗰𝘁 𝗵𝗲𝗮𝗱𝗲𝗿𝘀 — plus the flags that keep them in check.

Here is what stands out:
🎯 𝗞𝗻𝗼𝘄 𝗬𝗼𝘂𝗿 𝗗𝗲𝗳𝗮𝘂𝗹𝘁𝘀: On a "server" machine the 𝗝𝗩𝗠 claims only about 𝟮𝟱% of RAM for the 𝗵𝗲𝗮𝗽, so setting -𝗫𝗺𝘅 explicitly is the highest-leverage decision you can make.
🧩 𝗠𝗼𝗿𝗲 𝗧𝗵𝗮𝗻 𝘁𝗵𝗲 𝗛𝗲𝗮𝗽: 𝗠𝗲𝘁𝗮𝘀𝗽𝗮𝗰𝗲 (unbounded by default), 𝗖𝗼𝗱𝗲 𝗖𝗮𝗰𝗵𝗲, and 𝗢𝗳𝗳-𝗛𝗲𝗮𝗽 byte buffers all consume memory outside -𝗫𝗺𝘅, which is why container limits and heap size must be reconciled.
🪶 𝗟𝗶𝗴𝗵𝘁𝗲𝗿 𝗢𝗯𝗷𝗲𝗰𝘁 𝗛𝗲𝗮𝗱𝗲𝗿𝘀: -𝗫𝗫:+𝗨𝘀𝗲𝗖𝗼𝗺𝗽𝗮𝗰𝘁𝗢𝗯𝗷𝗲𝗰𝘁𝗛𝗲𝗮𝗱𝗲𝗿𝘀 in 𝗝𝗗𝗞 𝟮𝟰/𝟮𝟱 shrinks per-object overhead and has delivered measurable single-digit throughput gains in production.
🔍 𝗙𝗶𝗻𝗱 𝘁𝗵𝗲 𝗥𝗲𝗮𝗹 𝗖𝘂𝗹𝗽𝗿𝗶𝘁: Duplicated 𝗦𝘁𝗿𝗶𝗻𝗴𝘀 and boxed 𝘄𝗿𝗮𝗽𝗽𝗲𝗿 𝘁𝘆𝗽𝗲𝘀 dominate most heaps, and tools like 𝗘𝗰𝗹𝗶𝗽𝘀𝗲 𝗠𝗔𝗧 and 𝗡𝗮𝘁𝗶𝘃𝗲 𝗠𝗲𝗺𝗼𝗿𝘆 𝗧𝗿𝗮𝗰𝗸𝗶𝗻𝗴 show you exactly where.

For 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 teams running on 𝗞𝘂𝗯𝗲𝗿𝗻𝗲𝘁𝗲𝘀, this is the difference between a service that right-sizes cleanly and one that mysteriously dies under load with no stack trace to explain it.

Which 𝗝𝗩𝗠 flag has saved you the most pain? Share it below! 💬

(𝘓𝘪𝘯𝘬 𝘪𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘮𝘦𝘯𝘵 𝘴𝘦𝘤𝘵𝘪𝘰𝘯 𝘣𝘦𝘭𝘰𝘸 👇)

Happy learning! 👨‍💻🎉

02/08/2026

[English Below]
Hello mọi người!👋 Trong nhiều năm, cụm từ "𝗝𝗮𝘃𝗮 𝗶𝗻 𝘁𝗵𝗲 𝗯𝗿𝗼𝘄𝘀𝗲𝗿" nghe có vẻ như một di sản của thời kỳ applet — nhưng 𝗪𝗲𝗯𝗔𝘀𝘀𝗲𝗺𝗯𝗹𝘆 (𝗪𝗔𝗦𝗠) đã âm thầm đưa nó trở lại, và tốt hơn bao giờ hết.

Trong một bài talk gần đây, 𝗖𝗮𝘆 𝗛𝗼𝗿𝘀𝘁𝗺𝗮𝗻𝗻 (tác giả của 𝗖𝗼𝗿𝗲 𝗝𝗮𝘃𝗮) và 𝗝𝗲𝗳𝗳 𝗠𝗮𝗿𝘁𝗶𝗻 khám phá cách 𝗪𝗔𝗦𝗠 — một bytecode VM nhỏ gọn và được sandbox, chạy trên mọi trình duyệt — cho phép 𝗝𝗮𝘃𝗮 thực thi hoàn toàn ở phía client và thậm chí tại edge, mà không cần bất kỳ plugin nào.

Dưới đây là những điểm nổi bật:
🌐 𝗝𝗮𝘃𝗮 𝗶𝗻 𝘁𝗵𝗲 𝗕𝗿𝗼𝘄𝘀𝗲𝗿: Các công cụ như 𝗖𝗵𝗲𝗲𝗿𝗽𝗝, 𝗧𝗲𝗮𝗩𝗠 và 𝗚𝗿𝗮𝗮𝗹𝗩𝗠 𝗪𝗲𝗯 𝗜𝗺𝗮𝗴𝗲 biên dịch 𝗝𝗮𝘃𝗮 thật để chạy hoàn toàn trên client — không cần backend.
🔒 𝗦𝗲𝗰𝘂𝗿𝗲 𝗯𝘆 𝗗𝗲𝘀𝗶𝗴𝗻: 𝗪𝗔𝗦𝗠 rất dễ để sandbox một cách chính xác vì bản thân nó tối giản, tránh được bề mặt tấn công rộng lớn đã khai tử các applet.
📦 𝗧𝗿𝘂𝗲 𝗥𝘂𝗻-𝗔𝗻𝘆𝘄𝗵𝗲𝗿𝗲: Cùng một file JAR chạy trên desktop, tablet, điện thoại và thậm chí cả màn hình trên xe hơi, với thời gian khởi động chỉ khoảng một giây.
🔌 𝗣𝗼𝗹𝘆𝗴𝗹𝗼𝘁 𝗼𝗻 𝘁𝗵𝗲 𝗦𝗲𝗿𝘃𝗲𝗿: Với 𝗖𝗵𝗶𝗰𝗼𝗿𝘆 hoặc 𝗚𝗿𝗮𝗮𝗹𝗪𝗮𝘀𝗺, bạn có thể gọi an toàn các module 𝗥𝘂𝘀𝘁, 𝗚𝗼 hoặc 𝗖++ từ 𝗝𝗮𝘃𝗮.

Đối với các 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 developers, điều này mở ra hướng đi để xây dựng các client UI phong phú mà không cần React, và để sandbox các logic không đáng tin cậy trên server — mặc dù phần glue code hiện tại vẫn đòi hỏi sự cẩn thận thực sự.

Bạn đã thử biên dịch 𝗝𝗮𝘃𝗮 sang 𝗪𝗔𝗦𝗠 chưa? Hãy chia sẻ suy nghĩ của bạn bên dưới nhé! 💬

(𝘓𝘪𝘯𝘬 𝘣𝘦̂𝘯 𝘥𝘶̛𝘰̛́𝘪 𝘱𝘩𝘢̂̀𝘯 𝘣𝘪̀𝘯𝘩 𝘭𝘶𝘢̣̂𝘯👇)

Happy learning! 👨‍💻🎉

-------

Hello everyone!👋 For years, "𝗝𝗮𝘃𝗮 𝗶𝗻 𝘁𝗵𝗲 𝗯𝗿𝗼𝘄𝘀𝗲𝗿" sounded like a relic of the applet era — but 𝗪𝗲𝗯𝗔𝘀𝘀𝗲𝗺𝗯𝗹𝘆 (𝗪𝗔𝗦𝗠) has quietly brought it back, and better than ever.

In a recent talk, 𝗖𝗮𝘆 𝗛𝗼𝗿𝘀𝘁𝗺𝗮𝗻𝗻 (author of 𝗖𝗼𝗿𝗲 𝗝𝗮𝘃𝗮) and 𝗝𝗲𝗳𝗳 𝗠𝗮𝗿𝘁𝗶𝗻 explore how 𝗪𝗔𝗦𝗠 — a compact, sandboxed bytecode VM that runs in every browser — lets 𝗝𝗮𝘃𝗮 execute fully client-side and even at the edge, with no plugins required.

Here is why this stands out:
🌐 𝗝𝗮𝘃𝗮 𝗶𝗻 𝘁𝗵𝗲 𝗕𝗿𝗼𝘄𝘀𝗲𝗿: Tools like 𝗖𝗵𝗲𝗲𝗿𝗽𝗝, 𝗧𝗲𝗮𝗩𝗠, and 𝗚𝗿𝗮𝗮𝗹𝗩𝗠 𝗪𝗲𝗯 𝗜𝗺𝗮𝗴𝗲 compile real 𝗝𝗮𝘃𝗮 to run entirely on the client — no backend needed.
🔒 𝗦𝗲𝗰𝘂𝗿𝗲 𝗯𝘆 𝗗𝗲𝘀𝗶𝗴𝗻: 𝗪𝗔𝗦𝗠 is trivial to sandbox precisely because it is minimal, avoiding the broad attack surface that doomed applets.
📦 𝗧𝗿𝘂𝗲 𝗥𝘂𝗻-𝗔𝗻𝘆𝘄𝗵𝗲𝗿𝗲: The same JAR runs on desktop, tablet, phone, and even car consoles, with launch times around one second.
🔌 𝗣𝗼𝗹𝘆𝗴𝗹𝗼𝘁 𝗼𝗻 𝘁𝗵𝗲 𝗦𝗲𝗿𝘃𝗲𝗿: With 𝗖𝗵𝗶𝗰𝗼𝗿𝘆 or 𝗚𝗿𝗮𝗮𝗹𝗪𝗮𝘀𝗺, you can safely call 𝗥𝘂𝘀𝘁, 𝗚𝗼, or 𝗖++ modules from 𝗝𝗮𝘃𝗮.

For 𝗝𝗮𝘃𝗮/𝗦𝗽𝗿𝗶𝗻𝗴 developers, this opens a path to ship rich client UIs without React, and to sandbox untrusted logic on the server — though the glue code today still demands real care.

Have you tried compiling 𝗝𝗮𝘃𝗮 to 𝗪𝗔𝗦𝗠 yet? Share your thoughts below! 💬

(𝘓𝘪𝘯𝘬 𝘪𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘮𝘦𝘯𝘵 𝘴𝘦𝘤𝘵𝘪𝘰𝘯 𝘣𝘦𝘭𝘰𝘸 👇)

Happy learning! 👨‍💻🎉

Vietnam Java User Group - Vietnam JUG

09/08/2026

08/08/2026

07/08/2026

06/08/2026

05/08/2026

04/08/2026

03/08/2026

02/08/2026

Address

Website

Alerts

Shortcuts

Share

Category