The Blog

This post introduces a self-built website for studying AWS SAA-C03. The author explains how it organizes lessons into 23 chapters covering fundamentals, IAM, EC2, S3, VPC, RDS, Route 53, serverless, containers, security and encryption, plus decision trees, architecture patterns, service comparisons, and a practice exam. It also supports both English and Vietnamese, uses a simple responsive interface with sidebar navigation, and is meant to help learners study AWS in one place.

This article explains boxing and unboxing in C#, showing how a value type such as int, float, bool, or struct is wrapped into an object on the heap, and why that matters in Unity. It describes how boxing creates memory allocations that lead to GC pressure, spikes, and FPS drops, especially in update loops, and notes that boxing can happen implicitly through Debug.Log, interface calls on structs, generic misuse, LINQ, foreach over struct enumerators, event arguments, and List<object>. The post then gives practical ways to avoid boxing, such as not storing value types in object, using generics instead of interfaces when possible, casting to string for Debug.Log, using struct-friendly systems like ECS and Burst, and watching for GC Alloc in the Unity Profiler or Deep Profile. It ends with a simple summary: boxing turns a struct into an object, creates garbage, triggers GC, and should be avoided in performance-critical Unity code.

This article explains what UniTask is and why it is widely used in Unity. It describes how UniTask, made by Cysharp, is designed to replace IEnumerator + StartCoroutine, standard async Task, and older callback patterns. The post compares the main problems of traditional Unity coroutines and .NET Task in Unity, especially poor control, no proper cancellation, missing return values, and heavy GC allocations. It then shows how UniTask solves these issues with zero-allocation async/await, awaitable Unity workflows such as scene loading, animation, frame waiting, and DOTween, plus support for CancellationToken and real multithreading. The article also reviews alternatives like pure Coroutine, async Task, and third-party promise libraries, and concludes with practical cases where UniTask is useful in real games and why many Unity studios rely on it.

This article explains Coroutine, async/await, UniTask, and real multithreading in Unity/C#. It shows that Coroutine is a Unity-managed pseudo-asynchronous mechanism on the main thread, good for animation, delays, and simple gameplay flow, but not true multithreading. It then covers C# async/await, noting that async does not always mean multithreading and can also be used for background tasks or non-blocking I/O. Next, it introduces UniTask as a Cysharp library that brings async/await into Unity, supports awaitable yield instructions, returns values, and uses a zero-allocation struct-based design for better Unity performance. The article also reviews true multithreading APIs in C# such as Thread, ThreadPool, Task, Parallel.For, and PLINQ, and warns that Unity APIs like GameObject and Transform are not thread-safe. Finally, it compares the approaches and recommends using Coroutine for small gameplay flow, UniTask for scene loading and async operations, and Task/Thread only for heavy data processing while syncing results back to the main thread.

This article explains what Redis is: a very fast in-memory temporary data store, like RAM for servers, used to cache short-lived data. It describes Redis’s key-value data model, why it is fast, and common uses such as cache, session storage, job queues, pub/sub messaging, and leaderboards/counters. It also covers persistence with RDB and AOF, TTL-based automatic expiration, cluster mode with master and replica nodes, and other uses in game servers, IoT, machine learning, and analytics.

This article explains Serialization and Deserialization in plain terms: converting an object into storable or transferable data such as strings, files, bytes, or JSON, and converting that data back into an object. It uses a game-save example to show how this works in practice, then explains why serialization is needed for saving/loading, network communication, APIs, databases, cloud storage, Unity Editor and Inspector display, and cache or config data. It also outlines the basic flow with C# and describes serialization in Unity, including how scene, prefab, and ScriptableObject data are saved and what Unity can serialize. The post then compares common types of serialization—JSON, Binary, XML, and custom serialization—and gives a Unity game save system example for saving and loading player data. Finally, it summarizes the benefits of serialization, such as easier storage and transfer and support for common formats, as well as the risks, including unsupported types, editable JSON data, binary version compatibility issues, and the need for security in online use.