rlaope
estudy
Essentials · 8
Server · 103
- KISS, YAGNI, DRY
- Authentication vs. Authorization
- Efficient Design Methods for Back-end API Documentation
- Java Backend Web Technology History
- Clean Architecture with Spring Boot
- ☁️ Understanding OAuth 2.0 Concepts and Grant Types
- 3rd Karrot SRE Meetup
- Checking Test Coverage in IntelliJ
- SOLID Principles and the Pros and Cons of Each
- Differences in the Directions Kotlin and JPA Pursue
- Netty
- Netty Thread Model
- Netty Message Flow
- Netty Thread Model, EventLoop
- ByteBuf, Memory Management
- Mechanism by which Netty identifies completed tasks
- Netty Async Flow Control
- EventLoopGroup
- NioEventLoop vs EpollEventLoop
- Netty Native Memory Tuning, BackPressure
- Reactive Programming: What You Need to Know
- Elegant Spring Batch by Woowa Bros. Lee Dong-wook
- Cache Eviction, Expiration, Passivation
- Protocol Buffers
- Apache Kafka Key Components: Producer, Consumer, Topic, Partition, Segment
- Apache Kafka Key Components 2: Zookeeper, Broker + Clustering Walkthrough
- Understanding the PUB/SUB (Publish/Subscribe) Architecture
- Kafka Rebalancing
- Kafka Consumer Offset Manual Commit
- Kafka ISR(In Sync Replica)
- Producer Key Options
- Kafka Disk I/O
- How Kafka Replication Works
- Kafka Partition Assignment Strategies
- State Machine
- Kafka Partition
- State Machine Pattern
- How are sessions shared and managed in a multi-environment?
- Distributed Consensus Algorithm Paxos
- Kernel
- Block IO (Buffer Head, BIO Struct, Scheduler)
- Command nmap
- LXC (Linux Container)
- Linux Performance analysis commands
- uptime
- dmesg
- free
- df
- top
- netstat
- epoll
- Linux File System
- Kernel Space vs User Space
- System Call Interface
- buffer_head
- Time Synchronization Issues in Distributed Systems
- Distributed System Logical Clocks (Lamport Clock, Vector Clock)
- Implementing DR with IDC Redundancy + Kafka
- Data Partitioning
- What is MSA Microservice Architecture?
- Microservices from the Perspective of the Scaling Cube
- MSA, MA, SOA(Service Oriented Architecture), ESB, SOAP
- Reasons Not to Use DNS and Load Balancer for Service Discovery
- Microservice Client Resilience Patterns
- Two Phase Commit
- Saga Pattern
- Event Sourcing
- CQRS
- Transactional Outbox Pattern
- Microservice Architecture IPC
- Synchronous RPI Pattern Application Communication
- 서비스 디스커버리 Service Discovery
- Asynchronous Message Pattern Application Communication
- Service Mesh
- Istio, Istio Architecture
- Envoy Proxy Internal Architecture
- xDS Protocol, Control Plane (Istio Pilot)
- Traffic Control & Security mTLS
- Istio Circuit Breaker
- Managing Distributed Transactions in Microservices
- SRE
- SLO, SLI, SLA
- Socket Programming
- Encryption Algorithm AES256
- Low Level, JVM Async Programming
- Data-Driven Thinking (Observability + Capacity Planning)
- Failover Consistency
- Netty Proxy
- TCP Syn, Accept Queue
- Handling Resource Constraints of External Integration Systems and Surging Traffic
- 성능 테스트
- WAL, Distributed System Data Consistency, and Disaster Recovery Patterns
- Cache System Design
- Cache System Design and Implementation
- Cache Zero-Downtime Migration (Lazy Migration)
- Identifying Failure Points and Designing C/A Systems
- When a master node goes down after acquiring a distributed lock
- Controlling Cache Stampede (Distributed Lock, PER)
- Large-Scale DB and Data Migration (DB & Storage)
- Resolving SNAT Port Exhaustion and DNS Resolution Latency Issues
- Handling Duplicate Messages and Ensuring Idempotency During Kafka Partition Rebalancing
- Distributed Consensus Algorithms
- Why Zookeeper Adopted Paxos
DevOps · 114
- DevOps Engineer
- Docker and Kubernetes
- Differences between IaaS, PaaS, and SaaS
- CI/CD Pipeline and Implementation Process
- Virtual Machine vs. Container
- Types of Deployment Strategies (Rolling/Blue-Green/Canary)
- Docker Container
- Container Control Commands
- Container Management Commands
- Image-Related Commands
- Let's Spin Up a Docker Container
- Exposing Containers Externally
- Building Container Applications
- Using Docker Volumes
- Docker Network Structure
- Container Logging
- Container Resource Limits
- Creating a Docker Image
- Docker Swarm
- Deploying a Spring Project Using Docker
- permission denied while trying .. Docker demon socket Troubleshooting
- Docker Engine LXC, libcontainer
- Namespace, Container + runc syscall tracking
- Kubernetes
- Desired State
- Kubernetes Components
- Kubernetes API Resources
- Kubernetes Operation Flow
- Kubernetes Dashboard Token Issuance and Access
- Kubernetes Cluster
- Control Plane
- Pod
- Pod LifeCycle(Phase, Condition)
- Pod Lifecycle, Restart Policy
- Multi-Container Pod Design Patterns
- QoS Classes
- Node Scheduling
- Probe
- Service - Cluster IP, Node Port, Load Balancer
- Service - Headless, Endpoint, ExternalName
- ReplicaSet
- Deployment
- DaemonSet, Job, CronJob
- Volume - emptyDir, hostPath, PV/PVC
- ConfigMap, Secret
- Namespace, ResourceQuota, LimitRange
- Cluster Autoscaler, Karpenter
- Scheduler, Controller
- PV/PVC, Dynamic Provisioning
- Kubernetes Network
- K8s RBAC, Security Policy
- Agile Methodology
- K8s Deployment Strategies, Probes
- Cloud Architecture
- Node Components
- Hybrid Cloud
- Testing
- Walkthrough, Inspection
- What is TDD (Test-Driven Development)
- GitHub Actions
- Basic Concepts of Cloud and AWS
- What is Amazon Web Service EC2
- EC2 Pricing Policies and Instance Types
- EBS, Instance Storage, AMI
- AWS Security Group
- AWS ELB (Elastic Load Balancer), Sticky Session
- Auto Scaling
- VPC
- NAT, NAPT, and AWS NAT Gateway
- AWS Routing Tables
- Difference Between High Availability and Fault Tolerance
- AWS RDS (Relational Database Service)
- Elastic IP
- Systems Manager Session Manager
- Amazon Aurora, Aurora Architecture
- AWS Aurora 2nd
- CloudWatch vs CloudTrail
- SES Simple Email Service
- SNS SImple Notification Service
- SQS
- Optimization Improvements for Amazon SQS Speed and Scaling
- CloudFront
- AWS ECR (Elastic Container Registry)
- AWS ELK (Elastic Search Logstash Kibana)
- How to Access Private EC2 via Bastion Server + Hi-v2 Troubleshooting
- CloudWatch
- EKS
- EKS CNI
- Pod Communication Process
- EKS ALB Controller
- Creating and Deleting NLB and ALB
- Site to Site VPN
- DX (Direct Connect)
- Monolithic Architecture
- APM (Application Performance Management)
- gRPC, RPC, How It Works, HTTP API Comparison
- RabbitMQ
- Blue/Green Deployment and Architecture
- Nginx
- ELK and Logging Configuration
- Prometheus, Grafana
- Prometheus Exporter - Monitoring Agent
- Blue/Green Deployment, Auto Scaling
- Server Redundancy Architecture
- GitOps
- HCL Language
- Terraform Custom Condition(precondition, postcondition)
- Terraform] 작동 원리
- Terraform dynamic block
- Terraform] state, remote_state, backend
- MicroService Monitoring System (cc. Loki/Grafana)
- Presto
- Service Discovery Patterns in MSA
- IAM (Identity and Access Management)
SRE · 51
- Parallel GC Hang Alert
- Main Causes of Pod Pending Status
- kube-proxy Role
- Differences between iptables and ipvs
- CNI (Container Network Interface)
- Pod to Pod Cross-Node Packet Flow
- HPA (Horizontal Pod Autoscaler) Operation Principle
- Potential Risks When Using VPA
- Necessity of PDB (Pod Disruption Budget)
- Node Pressure (OOM, DiskPressure)
- Classifying CrashLoopBackOff Causes
- Comparing StatefulSet and Deployment
- Ingress vs. Service
- Pod Management Process in kubelet
- Liveness, Readiness, Startup Probe Comparison
- The Role of containerd
- How OOM Killer Works
- Why epoll is More Efficient Than select/poll
- Interpreting CPU Load Average
- CPU and Memory Control Methods in cgroup
- Symptoms of File Descriptor Exhaustion
- Causes of TCP TIME_WAIT Increase
- Causes of DNS Lookup Timeout
- Why Using Swap Is Dangerous
- Performance Issues Arising from NUMA Architecture
- Thread Pool Size Calculation Principles
- Advantages of Prometheus's Pull Model
- Alertmanager's Role
- p95·p99 Latency Difference Analysis
- The Dangers of High Cardinality
- Necessity of Filtering in Log Collection Systems
- Role of Jaeger and Tempo
- OpenTelemetry Structure
- Comparing SLO and SLI
- Symptoms of MTU Mismatch
- The Danger of Retry Thundering Herd
- Connection Pool Exhaustion Symptoms
- Nginx 502·504 Difference
- How to Detect Slow Queries
- Causes of Thread Overflow
- Root Causes of Increased GC Pause
- Priority Judgment Criteria During Outage Response
- Incident Severity Calculation Method
- How to Establish a Rollback Strategy
- Blue/Green Deployment vs Canary Deployment
- How to Configure DNS Failover
- How to Write Post-Mortem Action Items (Including Runbooks)
- Incident Flow: Detection → Triage → Mitigation → RCA
- Alert Fatigue Reduction Strategies
- Stability Checks to Consider for Deployment Automation
- Applying SLA and Error Budget
Languages · 168
- Java
- Object-Oriented
- JVM Memory Structure
- JMM (Java Memory Model)
- JVM Memory Model
- JVM GC
- Types of GCs and Their Differences
- Four Types of Garbage Collectors
- G1GC
- Java String Pool
- 4 Characteristics of OOP
- 5 Object-Oriented Principles
- Class, Object, Instance
- Constructors and Initialization
- Overriding and Overloading
- Polymorphism
- Date, SimpleDateFormat Current Date, Time Output
- Collection Framework
- Exception Handling
- RuntimeException and Exception
- HashMap Methods and Usage
- Understanding Optional
- What is a Web Servlet?
- StringBuilder Usage and Key Methods
- Wrapper Class, Boxing and Unboxing
- Java Generic
- SocketAddress Class & NetworkInterface Class
- Java String, StringBuilder, StringBuffer 차이 알아보기
- 🧐 Understanding POJO (Plain Old Java Object)
- Java Reflection
- Java Executors
- Java Callable, Future
- Java Cleaner, PhantomReference class
- How to Resolve OutOfMemoryError
- Java's Four Reference Types (Strong, Weak, Soft, Phantom)
- Java 8 Functional Interface
- Built-in Functional Interfaces in Java
- Reactive Stream, Backpressure, API Components
- Cold Publisher & Hot Publisher
- Java AIO
- JDK Proxy, CGLib Proxy
- Hotspot VM, JIT Compiler, and Their Limitations
- GraalVM
- Native Image
- Memory Optimization for Native Images
- Java Exception Creation Cost, and How to Reduce It
- JVM Warm Up - Causes of Latency Degradation Immediately After Deployment
- Applying JVM Warm Up
- ReentrantLock, Condition
- JIT Compiler
- Native Memroy
- jemalloc
- jemalloc, arena, memory fragmentation
- JVM Heap Object Headers on Internals
- JVM Safepoint
- Bias Locking, Revocation
- CAS (Compare And Swap)
- vDSO(virtual Dynamic Shared Object)
- Object Header - Mark Word
- GC Write Barrier
- Card Table
- Incremental Update
- Parallel GC Tuning
- CMS GC (Tuning Strategy: Parallel, CMS)
- G1GC
- Evacuation Failure
- Why did G1GC choose SATB instead of Incremental Update?
- Mixed GC
- Concurrent Marking
- G1GC OpenJDK 8 and 11
- Humongous Object, Mixed GC Trigger
- ZGC (Z Garbage Collector)
- G1GC, ZGC Performance Comparison Test
- Marked0/1, Good/Bad Color
- Parallel GC to G1GC
- TLAB (Thread-Local Allocation Buffer)
- Safepoint and Polling Page
- Reactive Streams
- HotSpot JVM ZGC Barriers, NUMA Memory Allocation, and Safepoint Operations
- Object Lifecycle (Creation, Usage, Destruction)
- Methods of Java's Object Class
- PGO (Profile-Guided Optimization)
- What is the role of the Finalize method in Java?
- Devirtualization: Polymorphism Implemented by the JVM
- Abstract Methods and Abstract Classes
- 5 JVM Method Invocation Instructions
- JMM and Hardware Intersection
- Anatomy of JVM Observability Tool Principles
- JIT Compiler, GraalVM: Java Code to Machine Code Translation Process
- Kotlin DSL
- Creating Pair Instances with mapOf() and to
- Kotlin Object-Oriented Programming
- Functional Programming in Kotlin
- Kotlin Collections
- Kotlin Delegates
- Kotlin Scope Functions
- Kotlin Sequences and Lazy Evaluation
- Kotlin Functional Interfaces and SAM Constructors
- Kotlin] What is kapt?
- Why can't the Lombok library be used in Kotlin?
- Using Spring Framework with Kotlin
- Implementing Persistence with Data Classes
- @JvmField && @JvmStatic Annotations
- Writing Test Code with Kotest
- Kotlin Coroutines and Concurrency Programming
- My Favorite Kotlin companion object
- Kotlin Generics: Covariance, Contravariance, Invariance
- Kotlin Generics Star Projection, reified Types
- sortedWith, Comparator Sorting Lambda Expression
- Kotlin runCatching and Result Type
- Differences between Unit and Nothing in Kotlin
- How to Create a Singleton Class in Kotlin?
- What is the difference between `companion object` and `object`?
- Functions Outside a Class (A package-level/ Top-level function)
- Kotlin Class, Field vs Property
- Reducing Coupling with Kotlin Delegation
- Proper Null Handling with lateinit and Delegates.notNull<>()
- Efficiently using `use` when working with classes that require `.close()`
- infix, inline function
- sealed class
- Optimize Higher-Order Functions Using `inline fun`
- Coroutine
- What is Kotlin and Why Do We Need It?
- CoroutineDispatcher
- launch, async
- suspend fun
- Making Coroutine Jobs Lazy
- Coroutine Job State Management
- Coroutine State Variables
- CoroutineContext
- Understanding Handle, Handler, and HandleFunc
- Pointers and Dereferencing in Golang
- Using Sqlite3 with Go Databases
- REST API Server using gorilla/mux
- Function
- Basic Js
- Prototype
- Garbage Collection
- Object Methods
- Class
- Strings
- Math
- Array
- Array 2
- Data Immutability
- Destructuring Assignment
- export
- import
- Lodash
- JSON
- Storage
- Regular Expressions
- DOM API
- Frequently Used DOM API Summary
- Promise
- AJAX
- fetch API
- TypeScript
- Class
- Type
- Constructor, Access Modifiers, Getter and Setter
- Functions in TypeScript
- Interface
- Interface2
- Generic
- Component
- What is GIT?
- Issue
Frameworks · 93
- Node.js
- Npm(Node.js) - Basic Command Usage Summary
- What is the MVC Pattern?
- React
- Controller, Service, Repository
- TypeScript Compiler
- IoC Container (Inversion of Control)
- conflict - Resolving Conflicts
- What is a Spring Bean?
- git log - Check History
- Spring AOP (Aspect Oriented Programming) Concepts
- git Basic Commands Summary 2
- Spring AOP Library AspectJ
- Creating package.json
- Spring's Representative @Annotations and Their Roles
- pull request
- What is Spring JDBC, DataSource?
- version
- Spring Package Structure - Layered vs. Domain-Driven
- Other Commands
- Lombok: A Collection of @Annotations You Must Know
- 깃허브 용어정리
- About Spring Boot @Builder
- Managing Someone Else's Repo
- Spring/Spring URL Mapping
- Branch
- Spring Security AccessToken & RefreshToken
- Building a Server
- Log Management Every Developer Must Do: Slf4j Logger
- Remote Repository
- Understanding Jwt (Json Web Token)
- Reverting to a previous version,
- Validation using Spring Validation
- Class Components
- Spring Boot Exception Handling with @ExceptionHandler
- Package Installation / Uninstallation Commands
- (Spring boot + Security) Configuring SecurityConfig
- Functional Components
- Automating API Documentation with Swagger
- Spring] Let's fully understand IoC, DI, Spring Container, and Bean 📗
- Spring] What exactly is AOP (Aspect-Oriented Programming)? 🧐
- 💻 Understanding the Concept and Operation of Dispatcher-Servlet
- 🔒 Understanding the Characteristics and Differences Between Servlet Filter and Spring Interceptor
- Kotlin, Spring boot] copy() 깊은복사, 얕은복사 성능상의 이점
- Kotlin, Spring boot] 검색 api에서 find Query vs Internal Function 데이터 처리 효율
- 📗 Spring Boot Actuator API + Example using Spring Cloud
- 📗 Mastering Spring WebFlux, Reactive Stream, R2DBC, Mono, Flux
- Springboot에서 데이터베이스 인덱싱 하는 방법
- Annotations for Spring Security Authentication in Spring Tests
- Connection Pool in Spring, HikariCP
- Spring Boot Batch
- Is ControllerAdvice implemented with AOP? Let's look at its operation.
- How ObjectMapper Works and Additional Features Provided by Spring Boot
- Kotlin Test Framework mockk Usage
- Spring Data Binding, Converter, Formatter
- Spring Resource Interface, Resource Abstraction and Implementations
- ResourceLoader, ResourcePatternResolver, ApplicationContext and Resources Paths
- SecurityContextHolderStrategy (ThreadLocal, InheritableThreadLocal, Global)
- Spring Security Filter
- Difference between Mock and Stub Tests
- Plugins and Dependencies for Running Spring in Kotlin
- Spring Boot Embedded Web Server Tomcat Configuration, How to Configure Other Embedded Web Servers
- Flexible Parameter Handling with Spring ArgumentResolver
- Perform actions periodically using Spring Scheduler
- Configuring Spring Boot Project Profiles
- Bean Scope, DL(Dependency Lookup), Provider
- Separating Transactions Using Spring AOP and Dynamic Proxies
- Application Logic, Infrastructure Beans, Container Infrastructure Beans
- Bean Scopes, Potential Issues, and Solutions
- Spring WebFlux vs MVC, Internal Working Principles
- Spring Batch Technical Trade-offs
- Spring Batch Data Consistency Management
- Spring Data JPA and @Transactional
- How Spring Data JPA Works
- How to Control Spring AOP Advice Order
- Spring Data JPA @Modifiying
- High Hibernate Performance, NaturalId
- JPA Entity equals(), hashcode() overriding
- Persistence Context
- Flush
- Object and Table Mapping
- Automatic Database Schema Generation
- Hibernate
- Embedded Types @Embedded, @Embeddable
- How to find an object by FK using the @Query annotation
- JPA N+1 Problem Resolution Methods and Practical Application Tips
- Differences Between Regular Join and Fetch Join
- When to Use a Regular Join?
- JPA Propagation Transaction Propagation Steps
- JPA Proxy and Lazy Loading
- OSIV (Open Session In View)
- Bulk Update, Delete Operations and the Persistence Context
- Spring @Transactional Transaction Binding and Auto-Commit
Domain Driven Design · 11
- 🔨 DDD (Domain-Driven Design) and Domain Model
- Domain-Driven-Design] 바운디드 컨텍스트 (Bounded-Context)
- DDD] Understanding Domain-Driven Design Aggregates
- Application Service and Presentation Layer
- Features Requiring Multiple Aggregates and Domain Services
- Aggregate and Transaction Management
- Domain Model and Bounded Context
- Event - High Coupling Issue Between Systems
- Events, Handlers, Dispatchers
- Synchronous Event Processing Issues, Asynchronous Event Processing
- CQRS (Command Query Responsibility Segregation)
DataBase · 79
- Database
- Database 2
- SQL Basic Syntax Summary
- DDL (Data Definition Language)
- Concept and Types of Keys
- ORM Concepts, Types, and Application Methods
- 트랜잭션과 ACID
- Database Normalization
- Index and Its Working Principle for Database Performance
- Replication vs Clustering
- Database Sharding (Distributed Processing)
- CAP Theorem
- Data Modeling and Types of DBs Based on Data Characteristics
- Database Connection Pool
- Database Optimizer
- Optimizer Optimization, Goals, and Limitations
- Cluster and Conditions in Databases
- Clustering (Active Clustering, Standby Clustering)
- Entity, Attribute, Relation
- Identifier Types and Classification System
- Database Normalization
- Denormalization
- DDL (CREATE, ALTER, DROP, TRUNCATE) Practice
- DML (INSERT, UPDATE, DELETE, SELECT) Practice + TCL (COMMIT, ROLLBACK)
- DCL (GRANT, REVOKE) Practice, User Creation
- WHERE Clause Practice
- Practicing Data Sorting with ORDER BY
- GROUP BY, Practice Data Aggregation by Group with Aggregate Functions
- Summary of Join Operations
- INNER JOIN & OUTER JOIN Practice
- Practice Using SQL DATE Functions + DUAL Table
- Practice Modifying Data with REPLACE() Function
- Practice Truncating Character Data Using the SUBSTR() Function
- Case Sensitivity Practice Using UPPER() and LOWER() Functions
- Numeric Functions ROUND(), TRUNC(), CEIL() Practice
- SQL Window Functions (WINDOW FUNCTION)
- Hierarchical Queries (START WITH, CONNECT BY PRIOR, SIBLINGS BY)
- SQL NULL-Related Functions - NVL, NVL2, NULLIF, COALESCE
- Differences Between Procedures and Triggers
- SQL vs NoSQL
- MongoDB
- Document Database
- MongoDB Trade-offs (vs RDB)
- MongoDB - CRUD
- MongoDB Sharding
- MongoDB Data Recovery (UNDO, REDO)
- Redis
- Efficient Redis Server Configuration
- Redis Memory Management, Optimization Strategies
- Redis Fragmentation Ratio
- Redis Distributed Lock, RedLock
- Redis Cluster
- Redis Distributed Lock, Example Spring Boot
- How to Ensure Atomicity for Multiple Redis Commands
- Redis Architecture
- Redis Replication
- How to Prevent Data Loss During Redis Failover
- Redis important fact about replication
- Redis INCR
- Redis Serialization Sync
- Database Load Balancing (Partitioning, Sharding, Replication)
- 데이터베이스 파티셔닝
- 파티셔닝 종류와 분할 기준
- VARCHAR vs TEXT
- Serializability
- Recoverability
- Full-Text Search Index
- Covering Index
- MMR, BKA
- MySQL 8.0 InnoDB Locking
- Pessimistic Lock, Optimistic Lock
- LSM Tree
- B+Tree
- Improving LIKE Query Search Performance, Full-Text Search
- Improving Query Performance with Analytic Functions
- Deadlock
- MySQL MyISAM, InnoDB
- MySQL WAL
- InfluxDB
Design Pattern · 22
- Design Patterns
- Singleton Pattern
- Factory Method Pattern
- Abstract Factory Pattern
- Builder Pattern
- Prototype Pattern
- Template Method Pattern
- Observer Pattern
- Strategy Pattern
- Singleton Pattern
- State Pattern
- Chain of Responsibility Pattern
- Command Pattern
- 인터프리터 패턴
- Iterator Pattern
- Mediator Pattern
- Proxy Pattern
- Adapter Pattern
- Composite Pattern
- Decorator Pattern
- Facade Pattern
- Bridge Pattern
Network · 85
- IP (Internet Protocol)
- TCP & UDP
- PORT & DNS
- URI
- Web Browser Request Flow
- Everything is HTTP
- Client-Server Architecture
- Stateful, Stateless
- HTTP Messages
- 비 연결성 (connectionless)
- Let's Create an HTTP API
- HTTP Methods - GET, POST
- PUT, PATCH , DELETE
- Properties of HTTP Methods
- Client to Server Data Transfer
- HTTP API Design Examples
- HTTP Status Codes
- 2xx - Success
- 3xx - Redirection
- 4xx - Client Errors, 5xx - Server Errors
- HTTP Header Overview
- Negotiation, Transfer Methods
- General Information
- Authentication, Cookies
- Cache Basic Operation
- Validation Headers and Conditional Requests
- Cache and Conditional Request Headers
- Proxy Cache
- Network
- Network Protocols
- How the Internet Works
- HTTP
- How DNS Works
- Domain Name
- How Web Browsers Work
- Hosting
- Synchronization and Deadlock
- Meaning and Design Rules of RESTful API
- Protocols by Network Layer
- Apache Tomcat (Apache Tomcat)
- Network Web Communication Flow
- Web Cache (Proxy Server)
- CDN (Content Delivery Networks)
- P2P
- Switches and Routers, Switching and Routing
- Inbound, Outbound
- Circuit Switching and Packet Switching
- IP/IP Packet, Packet Delivery, Limitations
- OSI 7 Layers and TCP/IP 4 Layers
- TCP/IP Packet, TCP vs UDP
- Web Cache
- Cache Validation Headers ETag, If-None-Match
- L1, L2, L3, L4, L5, L6, L7 Switches
- WebSocket, Difference from HTTP
- SSL (Security Socket Layer), TLS (Transfer Layer Security)
- Message Queue (MQ) Concepts
- Subnetting & Supernetting Concepts and Easy Calculation Methods
- 3-way / 4-way Handshake
- Understanding VLANs - VLAN, Trunk, Access Port
- Cache Validation Headers, Last-Modified, If-Modified-Since
- VLAN
- SSL Handshake
- Router
- DHCP(Dynamic Host Configuration Protocol)
- TCP Header
- TCP Session Maintenance Keepalive
- TCP Flag, ECN
- Three QoS Implementation Models (Best Effort, IntServ, DiffServ)
- Token Ring, Ethernet
- Network Lines, VPN, DWDM
- Network Components
- Mac Address, IP Address
- Gateway, Subnet
- Switch in Action
- TCP State Machine
- HTTP Keep-Alive, TCP Keep-Alive
- HTTP Keep-Alive
- File Descriptor in Network(cc. KeepAlive)
- BGP(Border Gateway Protocol) Peering
- IPsec
- SYN Cookie
- TCP Window Size, MSS, SACK Permitted
- TCP Congestion Control
- Evolution and Standards of Loss-based Algorithms (Reno & CUBIC)
- Modern Networks and Next-Generation Congestion Control (BBR & QUIC)
Operating System · 35
- Application Software (Computer System General Study Notes)
- Process and Thread
- CPU Scheduling
- Runtime and Compile Time
- Swapping in OS
- HTTP 메서드
- Virtual Memory System
- OS] 운영체제 구조와 원리
- Mutex and Semaphore
- 스레드와 동시성
- Definition of Daemon Process
- 응용SW_2( 컴퓨터 시스템 일반 학습지 )
- Computing System
- Page Replacement Algorithms: FIFO, LRU, LFU, MFU, NUR
- Memory Fragmentation
- Hypervisor
- Spinlock, Mutex, Semaphore + Mutex vs. Binary Semaphore
- Compiler Optimization
- IPC(Inter Process Comunication)
- Process Memory Structure
- Cache Memory Structure and Operation
- Memory - Address, Contiguous allocation, MMU
- Paging, Fragmentation, TLB
- UDS, 0000.sock
- Parity bit, Pararell Paritiy, Hamming Code
- Process Architecture
- MMU, TLB, Page Table
- NUMA
- NUMA (Kernel Level)
- Page Cache, Buffer Cache
- Inode (Index Node)
- CPU Out-of-Order Execution, Barrier, Happens-Before
- Copy-on-Write (CoW) and `fork()` Memory Optimization
- CAS and the ABA Problem
- Lock-Free Data Structures and STM
Data Structure · 23
- LinearList
- Linked List
- Stack
- Queue
- Tree
- Binary Search Tree (BST)
- Abstract Syntax Tree
- Parse Tree
- AVL Tree
- Red-Black Tree: Red-Black Tree
- B-Tree
- B-Tree Data Deletion
- Graph
- Depth-First Search (DFS)
- Breadth-First Search (BFS)
- Data Structures and Algorithms
- Breadth-First Search (BFS)
- Depth-First Search (DFS)
- Greedy Algorithm
- Prim's Algorithm
- Dijkstra's Algorithm
- Bellman-Ford Algorithm
- Floyd-Warshall Algorithm
AI · 83
- One-Hot Encoding, Multicollinearity
- Overfitting, Underfitting
- Weight, Bias cc. Linear Regression
- Hyperparameters
- Regression Model Performance Metrics
- Logistic Regression Theory
- Training Set Scale Issues
- sklearn
- Support Vector Machine
- Neural Network Perception
- Tensor
- GPU Architecture
- CUDA
- Operator Fusion, Quantization
- TensorRT
- LLM Architecture & Inference Mechanics
- LLM Agent Architecture
- RAG Advancement Strategies
- Image Feature Extraction Feature Extraction
- ORB (Oriented FAST and Rotated BRIEF)
- CNN (Convolution Neural Network) Based Feature Extraction
- LSH(Locality-Sensitive Hashing)
- Elasticsearch Indexing & Vector Search
- Object Detection
- Quantitative Evaluation Metrics for Search Systems (IR Metrics & Evaluation)
- Metric Learning & CLIP
- Approximate Search Algorithms, HNSW (ANN & FAISS)
- Elasticsearch 8.x Native Vector Search and Hybrid Architecture
- AI Model Optimization and Inference Acceleration with ONNX & TensorRT
- AI Serving Architecture (Triton Inference Server & Dynamic Batching)
- Triton Inference Server
- vLLM
- LLM Gateway and Integrated Routing for Multi-Model (SaaS & Self-hosted)
- Modular RAG Pipeline and Integrated Interface Design
- AI Agent Tooling and Dynamic Prompt/Context Management Platform
- RAG and Agent Serving Pipeline
- LLM/Agent Quantitative Evaluation System
- Multi-tenant LLM Platform Environment and Resource Isolation
- Model Optimization and Inference Latency Optimization Pipeline
- Tuning Triton Inference Server config.pbtxt
- vLLM Engine Memory Optimization Based on PagedAttention
- Implementing a High-Performance Asynchronous API Layer Communicating with a Core Inference Engine
- Continuous Batching Algorithm
- Nesight Systems, PyTorch Profiler VRAM Memory Bottleneck Profiling
- LiteLLM Proxy Server Configuration
- Tenant-Specific Request Isolation and Authorization Middleware Development
- Token Bucket-Based Rate Limiting
- Implementing Noisy Neighbor Blocking Logic
- Observability Pipeline for Latency-Free Prompt Token Usage Logging
- Processing LLM API Responses
- Agent DAG based on LangGraph
- Evolution from RNN to Attention
- Checkpointing Application
- Self-Attention, Multi-Head Attention
- Agent Context Identification Router in Stateless Protocols
- Positional Encoding, Encoder-Decoder
- BERT, GPT
- SFT and Policy Learning
- Off-policy Distillation and Teacher-Student Learning
- On-policy SFT and Rejection Sampling Fine-Tuning
- Preference Optimization: DPO Family
- Online RL: PPO, GRPO, RLVR
- Self-Distillation and Iterative Self-Improvement
- Policy Distribution and On-policy / Off-policy Theory
- LLM Model Tuning Engineer Study
- Understanding Transformer and Causal LM Architectures
- Tokenizer and Context Length
- Understanding Pretraining Objectives and Loss
- Base Model, Instruct Model, Chat Model
- Differences Between Continual Pretraining and Fine-tuning
- Distinguishing Pretraining Data and SFT Data
- Hermes Agent, Agent Memory Layer
- Archaeology of OpenWeight Models (Kimi, GLM, Qwen, DeepSeek)
- DeepSeek
- Qwen
- GLM
- Kimi
- Mastering the LLM Inference Serving Engine SGLang
- Long-Term Memory Research
- QWEN Model Analysis
- Kimi Model Analysis
- DeepSeek V4.1 Flash Archaeology
- SIFT, SURF
AI/MLOps · 22
- CPU and GPU Design Philosophy Differences: Latency Optimization (CPU) vs Throughput Optimization (GPU)
- GPU Thread Execution Model
- GPU Internal Memory Hierarchy
- CUDA, Tensor Core
- HBM, Roofline Model
- PCIe Lane Structure, GPUDirect Storage, NUMA Optimization
- NVLink, NVSwitch
- ZeRO Optimizer (DeepSpeed, FSDP)
- Understanding Transformer Inference Execution Structure
- LLM Serving Benchmarks and Performance Metrics
- KV Cache and Batching Optimization
- 4. Quantization and Multi-GPU Parallelism
- Production Model Serving and Capacity Planning
- Agent Components and State Model Design
- Tool Calling and MCP-based Tool Design
- Durable Execution and Workflow Recovery
- GPU Hardware and Performance Models
- SGLang Serving Casebook
- Serving Playbook by Model Architecture
- Parallelization Strategies — TP, PP, EP, DP
- How a Model Loads onto a GPU
- Distributed Serving and Communication