jongkwan.dev

Posts

104 posts
  1. RAG Datastore Membership Inference: The Retrieval Corpus as Attack Surface

  2. Late Interaction Reranking

  3. LLM Agent Memory Poisoning

  4. LLM Jailbreaks and Automated Red Teaming

  5. Delay-based and rollback netcode

  6. Evaluating Multi-Agent Systems and Choosing an Orchestration Topology

  7. Agent Harnesses and Loop Engineering

  8. MCP Tool Poisoning

  9. LLM Privacy Defenses: DP, Encryption, TEEs, and Unlearning

  10. String Algorithms for Coding Tests

  11. LLM Privacy Attacks: Training Data Extraction and Membership Inference

  12. Advanced Graph Patterns for Coding Tests

  13. RAG Re-ranking: Cross-Encoders

  14. Verifying AI-Generated Code

  15. Dense Retrieval for RAG: DPR and the Dual Encoder

  16. Django FBVs and CBVs

  17. An Overview of Diffusion Language Models

  18. Observability Through Datadog

  19. AWS Container Services: ECS, EKS, and Fargate

  20. Output Guardrails, Observability, and the Right to Erasure

  21. Egress Gateway Defense

  22. Defenses at the Agent, RAG, and MCP Layers

  23. Input-Side PII Anonymization and Reversible Mapping

  24. How Personal Data Leaks, and What Data Governance Has to Cover

  25. Concurrency Control and Synchronization: From Mutexes to the Actor Model

  26. Designing a Live Streaming System

  27. Deploying and Operating Celery

  28. CRDT: Conflict-free Replicated Data Types

  29. Generating Every Elementary Function from a Single Operator — EML

  30. Celery Canvas Workflows: Chain, Group, Chord

  31. LSM Trees and Write Amplification

  32. Celery Task Routing and Reliability

  33. Database Transactions and MVCC

  34. Celery Architecture and the Message Lifecycle

  35. Scale-Out and Scale-Up: The Principles of Horizontal Scaling

  36. Spring Data Access Technologies

  37. Elasticsearch Operations and Performance Tuning

  38. Redis High Availability: Sentinel and Cluster

  39. The Spring MVC Request Flow

  40. Elasticsearch Sharding Architecture

  41. Redis Persistence and Replication

  42. Spring Transactions and Propagation

  43. Elasticsearch Query DSL and Aggregations

  44. Redis Memory Management and Eviction

  45. Spring AOP and Proxies

  46. Elasticsearch Mappings and Analyzers

  47. Test Automation

  48. Redis Data Structures and How to Use Them

  49. Spring DI and the IoC Container

  50. Exposing a Home Server Safely with Cloudflare Tunnel

  51. JWT Authentication and TOTP 2FA

  52. Agent Orchestration with LangGraph

  53. Momentum Trading Strategies

  54. Code Review and Commit Conventions

  55. Design Patterns for an Event-Driven Trading System

  56. Test-Time Compute Scaling

  57. Toolformer: A Model That Teaches Itself to Use Tools

  58. RAG

  59. Blue/Green Deployment (4): Operations and Optimization

  60. MADKE (Multi-Agent Debate with Knowledge Enhancement)

  61. Multi-Agent Debate

  62. LATS (Language Agent Tree Search)

  63. Blue/Green Deployment (3): Cloud and CI/CD Integration

  64. Tree of Thought (ToT)

  65. CRITIC: Verification Through External Tools

  66. Self-Refine

  67. Blue/Green Deployment (2): Implementing It on Kubernetes

  68. Reflexion

  69. ReAct (Reasoning + Acting)

  70. TLS and HTTPS: Handshakes and Certificates

  71. Chain of Thought (CoT) Step-by-Step Reasoning

  72. Blue/Green Deployment (1): Fundamentals and Strategy

  73. Transformer Architecture and LLM Serving Optimization

  74. Socket Programming

  75. Operating System I/O Management and File Systems

  76. Application Layer Protocols: HTTP and DNS

  77. Incident Response and Management: From On-Call to Postmortem

  78. Processes and CPU Scheduling

  79. The Transport Layer: TCP, UDP, and Congestion Control

  80. Operating System Memory Management: Virtual Memory and Paging

  81. System Calls and Interrupts

  82. Containerization and Orchestration: An In-Depth Guide

  83. Kubernetes in Depth: Networking, Storage, and Deployment Strategies

  84. Kubernetes Core Concepts

  85. Rust Overview: A Systems Language That Combines Safety and Performance

  86. Monitoring and Observability: Logs, Metrics, Traces

  87. Git Branching Strategies: From Git Flow to Trunk-Based

  88. TDD, BDD, DDD, SDD: Comparing Software Development Methodologies

  89. The Bellman-Ford Algorithm: Shortest Paths with Negative Weights

  90. Dijkstra's Shortest Path Algorithm

  91. Advanced Git: Internals and Advanced Commands

  92. Minimum Spanning Tree (MST) Algorithms

  93. Database Denormalization Strategies

  94. Behavioral Patterns - Distributing Responsibility and Communication Between Objects

  95. Load Balancing: From L4/L7 to eBPF and Service Meshes

  96. PostgreSQL vs MySQL Indexing

  97. A Guide to MySQL Partitioning

  98. Building Custom Pagination in Django

  99. Structural Patterns: Object Composition and Interface Design

  100. Creational Patterns - Encapsulating Object Creation

  101. Caching Strategies: Multi-Level Cache Architecture and Advanced Redis

  102. Network Layer Models and Data Communication

  103. The SOLID Principles

  104. Core Data Structures