API, runtime, thread ๊ฐ์ ๊ธฐ์ด ์ฉ์ด๋ถํฐ Kafka, Terraform, AWS, Spring, DB, p99, OOP, AI jargon๊น์ง ํ ๋ฒ์ ์ฐพ๋ ํ๋ จ ํ๋ฉด์ด๋ค. ์นด๋๋ฅผ ๋๋ฅด๊ณ ํ๊ตญ์ด๋ก ์ดํดํ ๋ค, raw English๋ฅผ ์๋ฆฌ๋ด์ ๋งํ๊ณ self-attack์ ๋ตํ๋ฉด ๋๋ค.
Search โ open card โ say raw English โ explain failure modes โ answer attacks โ mark explained.
์ฉ์ด ์๊ธฐ๊ฐ ์๋๋ผ, ๋ฉด์ ๊ด์ด๋ ๋๋ฃ์๊ฒ ๋ค ๋ง๋ก ๊ตฌ์กฐ์ ์ฅ์ ๊น์ง ์ค๋ช ํ๋ ํ๋ จ์ด๋ค.
The human-readable original of a program
์ฌ๋์ด ์ฝ๊ณ ์์ ํ๋ ํ๋ก๊ทธ๋จ ์๋ณธ
Source code is the human-readable version of a program.
Turns source code into something runnable
์์ค ์ฝ๋๋ฅผ ์คํ ๊ฐ๋ฅํ ํํ๋ก ๋ณํ
A compiler translates source code into a form the machine or runtime can execute.
Turning source code into a shippable artifact
์์ค ์ฝ๋๋ฅผ ๋ฐฐํฌ ๊ฐ๋ฅํ ์ฐ์ถ๋ฌผ๋ก ๋ง๋ฆ
A build turns source code into a deployable artifact.
The deployable output of a build
build ๊ฒฐ๊ณผ๋ก ๋์จ ๋ฐฐํฌ ๋์
An artifact is the output of a build that can be deployed or stored.
The environment where a program actually runs
ํ๋ก๊ทธ๋จ์ด ์ค์ ๋ก ์คํ๋๋ ํ๊ฒฝ
Runtime is the environment where the program actually runs.
A running program as the OS sees it
OS๊ฐ ์คํ ์ค์ธ ํ๋ก๊ทธ๋จ ๋จ์
A process is a running program managed by the operating system.
A flow of execution inside a process
process ์์์ ์คํ๋๋ ์์ ํ๋ฆ
A thread is an execution path inside a process.
Where a running program holds its data
ํ๋ก๊ทธ๋จ์ด ์คํ ์ค ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ณต๊ฐ
Memory is where a running program stores data while it executes.
Run contexts like dev, staging, and production
dev, staging, production ๊ฐ์ ์คํ ๋งฅ๋ฝ
An environment is the context where the application runs.
Behavior you can change outside the code
์ฝ๋ ๋ฐ์์ ๋ฐ๊พธ๋ ๋์ ์ค์
Configuration changes behavior without changing source code.
External code or services your code relies on
๋ด ์ฝ๋๊ฐ ์์กดํ๋ ์ธ๋ถ ์ฝ๋/์๋น์ค
A dependency is something my code relies on to work.
Reusable code your code calls into
๋ด ์ฝ๋๊ฐ ํธ์ถํ๋ ์ฌ์ฌ์ฉ ์ฝ๋ ๋ฌถ์
A library is reusable code that my application calls.
The skeleton that shapes your app's flow
์ฑ์ ๊ตฌ์กฐ์ ํ๋ฆ์ ์ก๋ ๋ผ๋
A framework gives the application structure and often controls the lifecycle.
A dev toolkit for a specific platform or API
ํน์ ํ๋ซํผ/API๋ฅผ ์ฐ๊ธฐ ์ํ ๊ฐ๋ฐ ๋๊ตฌ ๋ฌถ์
An SDK is a toolkit for building against a specific platform or API.
Installing dependencies and pinning versions
dependency ์ค์น์ ๋ฒ์ ๊ณ ์
A package manager installs dependencies and controls their versions.
The side making the request vs. the side answering it
์์ฒญํ๋ ์ชฝ๊ณผ ์๋ตํ๋ ์ชฝ
A client sends a request; a server handles it and returns a response.
A set of communication rules
ํต์ ๊ท์น์ ์งํฉ
A protocol is a set of rules for communication between systems.
The agreed boundary where systems talk to each other
์์คํ ๋ผ๋ฆฌ ์ฝ์๋ ๋ฐฉ์์ผ๋ก ๋ํํ๋ ๊ฒฝ๊ณ
An API is a contract for how one piece of software talks to another.
A concrete callable address or action on an API
API์์ ํธ์ถ ๊ฐ๋ฅํ ๊ตฌ์ฒด์ ์ฃผ์/๋์
An endpoint is a specific operation exposed by an API.
What GET, POST, PUT, PATCH, DELETE mean
GET, POST, PUT, PATCH, DELETE ์๋ฏธ
HTTP methods communicate the intent of an API operation.
Standard numeric codes for the result
์๋ต ๊ฒฐ๊ณผ๋ฅผ ํ์ค ์ซ์๋ก ํํ
An HTTP status code tells the caller how the request was handled.
The actual data body of a request or response
request/response์ ์ค์ ๋ฐ์ดํฐ ๋ชธํต
A payload is the actual data body sent in a request, response, or message.
Turning an object into something you can send or store
๊ฐ์ฒด๋ฅผ ์ ์ก/์ ์ฅ ๊ฐ๋ฅํ ํ์์ผ๋ก ๋ฐ๊ฟ
Serialization converts in-memory data into a format that can be stored or sent.
The shape and constraints of your data
๋ฐ์ดํฐ์ ๋ชจ์๊ณผ ์ ์ฝ
A schema defines the shape, types, and constraints of data.
The boundary that hides implementation and pins down how something is used
๊ตฌํ์ ์จ๊ธฐ๊ณ ์ฌ์ฉ๋ฒ์ ๊ณ ์ ํ๋ ๊ฒฝ๊ณ
An interface defines how something can be used without exposing all implementation details.
Surfacing only what matters and hiding the rest
์ค์ํ ๊ฒ๋ง ๋๋ฌ๋ด๊ณ ๋๋จธ์ง๋ฅผ ์จ๊น
An abstraction exposes what matters and hides unnecessary detail.
How much a change in one place forces changes elsewhere
ํ ๋ถ๋ถ ๋ณ๊ฒฝ์ด ๋ค๋ฅธ ๋ถ๋ถ์ ๋ฏธ์น๋ ์์กด์ฑ
Coupling is how strongly one part of the system depends on another.
How focused a module is on a single purpose
ํ ๋ชจ๋์ด ํ๋์ ๋ชฉ์ ์ ์ง์คํ๋ ์ ๋
Cohesion is how closely the responsibilities inside a module belong together.
Calls you wait on vs. work handled later
๊ธฐ๋ค๋ฆฌ๋ ํธ์ถ๊ณผ ๋์ค์ ์ฒ๋ฆฌ๋๋ ์์
Synchronous work blocks the caller; asynchronous work continues later or elsewhere.
Checking that input actually satisfies the rules
์ ๋ ฅ์ด ๊ท์น์ ๋ง์กฑํ๋์ง ํ์ธ
Validation checks whether input satisfies type, format, range, and business rules.
When the program can't finish its normal flow
ํ๋ก๊ทธ๋จ์ด ์ ์ ํ๋ฆ์ ์๋ฃํ์ง ๋ชปํ ์ํ
An error is a failure to complete the expected operation.
The call path that led to the error
์ค๋ฅ๊ฐ ๋ฐ์ํ ํธ์ถ ๊ฒฝ๋ก
A stack trace shows the call path that led to an error.
A record of what the system did
์์คํ ์ด ํ ์ผ์ ๊ธฐ๋ก
Logging records what the system did and what happened during execution.
The thing that runs background jobs
background ์์ ์ ์ฒ๋ฆฌํ๋ ์คํ ๋จ์
A worker processes background jobs outside the main request path.
Getting the artifact running in a target environment
artifact๋ฅผ ์คํ ํ๊ฒฝ์ ๋ฐ์
Deploy means putting a built artifact into a running environment.
Exposing the feature to users
์ฌ์ฉ์์๊ฒ ๊ธฐ๋ฅ์ ๋ ธ์ถ
Release means exposing a capability to users.
Safely changing your DB schema or data shape
DB schema๋ data shape๋ฅผ ์์ ํ๊ฒ ๋ฐ๊ฟ
A migration changes the database schema or data from one version to another.
Multiple things in progress at once
์ฌ๋ฌ ์์ ์ด ๊ฒน์ณ ์งํ๋๋ ์ํ
Concurrency means multiple pieces of work are in progress at overlapping times.
Concurrency is structure, parallelism is execution
๋์์ฑ์ ๊ตฌ์กฐ, ๋ณ๋ ฌ์ฑ์ ์คํ
Concurrency is structuring a program so independent tasks can make progress overlapping in time, while parallelism is literally executing multiple tasks at the same instant on separate cores.
A bug where the outcome depends on timing
์คํ ์์์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง๋ ๋ฒ๊ทธ
A race condition happens when timing or ordering changes the result.
Code that behaves correctly under concurrent access with no extra caller coordination
ํธ์ถ์๊ฐ ์ถ๊ฐ ์กฐ์จ ์์ด ๋์ ์ ๊ทผํด๋ ์ ํํ ๋์ํ๋ ์ฝ๋
Thread safety means a class behaves correctly under concurrent access by multiple threads with no additional synchronization required from the caller.
Lock only the smallest region that touches shared state
๊ณต์ ์ํ๋ฅผ ๋ง์ง๋ ์ต์ ๊ตฌ์ญ๋ง ๋ฝ์ผ๋ก ๋ณดํธํ๋ผ
A critical section is the region of code that accesses shared mutable state and must run with mutual exclusion โ one thread at a time โ and you keep it as small as possible, doing slow work like I/O outside the lock.
A mutual-exclusion lock that lets exactly one thread into the critical section at a time
ํ ๋ฒ์ ํ ์ค๋ ๋๋ง ์๊ณ ์์ญ์ ๋ค์ด๊ฐ๋๋ก ๋ณด์ฅํ๋ ์ํธ ๋ฐฐ์ ๋ฝ
A mutex is a lock that guarantees only one thread at a time can hold it and enter the protected critical section.
The same thread can re-acquire a lock it already holds (hold count)
์ด๋ฏธ ์ก์ ๋ฝ์ ๊ฐ์ ์ค๋ ๋๊ฐ ๋ค์ ์ก์ ์ ์๋ค (hold count)
A reentrant lock lets a thread that already holds the lock acquire it again by incrementing a hold count, so a synchronized method calling another on the same monitor won't self-deadlock.
A counting sync primitive that caps concurrent access to N permits
N๊ฐ์ permit์ผ๋ก ๋์ ์ ๊ทผ ์๋ฅผ ์ ํํ๋ ์นด์ดํ ๋๊ธฐํ ์ฅ์น
A semaphore is a counter of N permits where acquire() takes a permit (blocking if none are left) and release() returns one, used to cap how many threads access a resource concurrently.
Many readers at once, one writer alone
์ฝ๊ธฐ๋ ๋์์, ์ฐ๊ธฐ๋ ๋จ๋ ์ผ๋ก
A read-write lock lets any number of threads hold the read lock concurrently but grants the write lock exclusively, so it optimizes shared state that's read far more often than it's written.
Release the lock, sleep until a predicate holds, get woken by a signal
๋ฝ์ ๋๊ณ ์กฐ๊ฑด์ด ์ฐธ์ด ๋ ๋๊น์ง ์ ๋ค์๋ค๊ฐ signal๋ก ๊นจ์ด๋๋ค
A condition variable lets a thread atomically release a lock and sleep until another thread signals that a predicate may now be true, re-acquiring the lock before it returns.
Decouple producers and consumers with a bounded queue that applies backpressure
์์ฐ์์ ์๋น์๋ฅผ bounded queue๋ก ๋ถ๋ฆฌํ๊ณ backpressure๋ฅผ ๊ฑด๋ค
Producer-consumer uses a bounded blocking queue between producers and consumers so the queue handles synchronization and applies backpressure: put() blocks when the queue is full, take() blocks when it's empty.
Lock-free atomic update: swap only if the current value still matches what you expected
๋ฝ ์์ด ์์์ ์ผ๋ก ๊ฐ ๋ฐ๊พธ๊ธฐ: ๊ธฐ๋๊ฐ์ด ๋ง์ ๋๋ง ๊ต์ฒด
Compare-And-Swap is a single atomic CPU instruction that writes a new value to a memory location only if its current value equals the expected value, and reports success or failure.
CAS sees the value, not the history โ it misses AโBโA
CAS๋ ๊ฐ๋ง ๋ณด์ง ๋ณํ ์ด๋ ฅ์ ๋ชป ๋ณธ๋ค โ AโBโA๋ฅผ ๋์น๋ค
ABA is when a CAS succeeds because the value is still A, even though it went A to B and back to A, so a stale thread wrongly thinks nothing changed.
One thread's write isn't visible to another without synchronization
ํ ์ค๋ ๋์ ์ฐ๊ธฐ๊ฐ ๋ค๋ฅธ ์ค๋ ๋์ ๋ณด์ด๋ ค๋ฉด ๋๊ธฐํ๊ฐ ํ์ํ๋ค
Without synchronization a write by one thread may never become visible to another; volatile fixes that by guaranteeing visibility and establishing a happens-before ordering, but it does not make compound operations atomic.
When one thread's write becomes visible to another
ํ ์ค๋ ๋์ write๊ฐ ๋ค๋ฅธ ์ค๋ ๋์ ์ธ์ ๋ณด์ด๋๊ฐ
The Java Memory Model defines, via happens-before edges, exactly when one thread's write is guaranteed visible to another thread's read; without such an edge the JVM and CPU are free to reorder and cache, so the reader may see stale or partially-constructed state.
Optimistic when conflicts are rare, pessimistic when frequent
์ถฉ๋์ด ๋๋ฌผ๋ฉด ๋๊ด์ , ์ฆ์ผ๋ฉด ๋น๊ด์
Pessimistic locking grabs a row lock upfront with SELECT FOR UPDATE assuming conflict, while optimistic locking takes no lock, reads a version, and updates WHERE version equals the read value, retrying when zero rows change.
Two threads each waiting on the other's lock, frozen forever in a circular wait
๋ ์ค๋ ๋๊ฐ ์๋ก์ lock์ ๊ธฐ๋ค๋ฆฌ๋ฉฐ ์์ํ ๋ฉ์ถ๋ ์ํ ๋๊ธฐ
Deadlock is when two or more threads each hold a lock the other needs, forming a circular wait so none can ever proceed.
Not blocked, but threads keep reacting to each other and never make progress
๋งํ์ง ์์๋๋ฐ ์๋ก ์๋ณด๋ง ํ๋ค ์์ํ ์ง์ ์ด ์๋ ์ํ
Livelock is when threads aren't blocked but keep changing state in response to each other so no thread ever makes forward progress.
One thread perpetually denied the resource it needs
ํ ์ค๋ ๋๊ฐ ์์์ ์์ํ ๋ชป ์ก๋ ๊ธฐ์ ์ํ
Starvation is when a thread is perpetually denied a resource it needs because other threads keep acquiring it first, so it never makes progress.
A lock that keeps checking instead of sleeping โ only for very short critical sections
์ ๋ค์ง ์๊ณ ๊ณ์ ํ์ธํ๋ ๋ฝ โ ์์ฃผ ์งง์ ์๊ณ ๊ตฌ์ญ์๋ง
A spinlock makes a thread busy-wait in a tight retry loop until it acquires the lock, instead of blocking and yielding the CPU.
No logical sharing, yet the shared cache line silently kills throughput
๋ ผ๋ฆฌ์ ์ผ๋ก ์ ๊ฒน์น๋๋ฐ ๊ฐ์ cache line ๋๋ฌธ์ ๋๋ ค์ง๋ค
False sharing is when two independent variables land on the same CPU cache line, so writes from threads on different cores keep invalidating each other's line even though they never touch the same data.
The cost of the CPU saving/restoring thread state โ too many threads and switching costs more than the work
CPU๊ฐ ์ค๋ ๋ ์ํ๋ฅผ ์ ์ฅ/๋ณต์ํ๋ ๋น์ฉ โ ๋๋ฌด ๋ง์ผ๋ฉด ์ผ๋ณด๋ค ์ ํ์ด ๋ ๋ ๋ค
A context switch is when the OS saves one thread's CPU state and loads another's so they can share cores, which costs CPU cycles plus cache eviction.
Capping and reusing worker threads
์์ ์คํ thread ์๋ฅผ ์ ํํ๊ณ ์ฌ์ฌ์ฉ
A thread pool reuses threads and bounds concurrent execution.
Less locking: ConcurrentHashMap, CopyOnWrite, BlockingQueue
๋ฝ ์ค์ด๊ธฐ: ConcurrentHashMap, CopyOnWrite, BlockingQueue
Concurrent collections replace one coarse lock with finer-grained strategies โ CAS plus per-bin locking in ConcurrentHashMap, copy-on-write snapshots for read-heavy lists, and blocking handoff in BlockingQueue โ so they scale under contention where Collections.synchronizedMap serializes everything on a single monitor.
Heap, stacks, Metaspace โ what lives where and which OOM each one throws
Heap, ์คํ, Metaspace โ ๋ฌด์์ด ์ด๋์ ์ด๊ณ ์ด๋ค OOM์ด ํฐ์ง๋๊ฐ
JVM memory splits into shared regions โ the heap (Young/Old) for object instances and Metaspace for class metadata โ and per-thread regions โ the stacks that hold locals and references, while JIT code lives in the code cache and direct buffers live off-heap.
Reclaiming memory from objects you no longer use
์ฌ์ฉํ์ง ์๋ ๊ฐ์ฒด memory๋ฅผ ํ์
Garbage collection reclaims unreachable objects in the JVM heap.
Four JVM locks: default to synchronized, climb to explicit locks only when you need their features
JVM ๋ฝ 4์ข : ๊ธฐ๋ณธ์ synchronized, ํ์ํ ๋๋ง ๋ช ์์ ๋ฝ์ผ๋ก ์ฌ๋ผ๊ฐ๋ค
They all give you mutual exclusion but trade off differently: synchronized is the auto-released default, ReentrantLock adds tryLock/timeout/fairness/conditions, ReadWriteLock lets concurrent readers in for read-heavy data, and StampedLock adds lock-free optimistic reads but isn't reentrant and has no conditions.
Mutual exclusion across nodes: TTL + fencing token are the core
์ฌ๋ฌ ๋ ธ๋ ์ฌ์ด์ ์ํธ ๋ฐฐ์ : TTL + fencing token์ด ํต์ฌ
A distributed lock provides mutual exclusion across separate processes or nodes using a shared store like Redis SET NX PX, a DB lease row, or ZooKeeper, and it must carry a TTL plus a fencing token so a dead or stalled holder can't corrupt shared state.
A resource-oriented HTTP interface
resource ์ค์ฌ HTTP interface
A REST API exposes resources using HTTP methods and status codes.
Takes the HTTP request and hands it to the app logic
HTTP ์์ฒญ์ ๋ฐ์ application logic์ผ๋ก ๋๊น
A controller handles an incoming request and delegates the actual work to the application layer.
Where use cases and business workflows live
use case์ business workflow๋ฅผ ๋ด๋ ์ธต
The service layer coordinates a business use case.
Keeping the domain from knowing the persistence details
domain์ด persistence ์ธ๋ถ์ฌํญ์ ์ง์ ์์ง ์๊ฒ ํจ
A repository hides persistence details behind a collection-like interface.
The data shape you pass across layers or the network
๊ณ์ธต/๋คํธ์ํฌ ์ฌ์ด๋ก ์ฎ๊ธฐ๋ ๋ฐ์ดํฐ ๋ชจ์
A DTO is a data shape used to transfer data across a boundary.
Converts one data shape into another
ํ ๋ฐ์ดํฐ ๋ชจ์์ ๋ค๋ฅธ ๋ชจ์์ผ๋ก ๋ณํ
A mapper converts one data shape into another.
The function or component that processes a request, event, or job
ํน์ event/request/job์ ์ฒ๋ฆฌํ๋ ํจ์๋ ์ปดํฌ๋ํธ
A handler is the piece of code responsible for handling a specific request, event, or job.
Shared logic that sits in the request/response path
request/response ํ๋ฆ ์ค๊ฐ์์ ๊ณตํต ์ฒ๋ฆฌ
Middleware runs in the middle of the request-response pipeline.
The basic data ops: create, read, update, delete
Create, Read, Update, Delete ๊ธฐ๋ณธ ๋ฐ์ดํฐ ์์
CRUD means Create, Read, Update, and Delete.
Spring wiring up object creation and dependencies
๊ฐ์ฒด ์์ฑ๊ณผ ์์กด์ฑ ์ฐ๊ฒฐ์ Spring container๊ฐ ๊ด๋ฆฌ
Dependency injection means objects receive dependencies instead of constructing them.
Spring applying a transaction at the method boundary
Spring์ด method ๊ฒฝ๊ณ์ transaction์ ์ ์ฉ
@Transactional applies transaction boundaries through a Spring proxy.
The first-level cache that tracks entities and detects changes
entity๋ฅผ ์ถ์ ํ๋ 1์ฐจ cache์ ๋ณ๊ฒฝ ๊ฐ์ง ๊ณต๊ฐ
The persistence context tracks entities and flushes changes to the database.
Reuses DB connections and caps concurrency
DB ์ฐ๊ฒฐ์ ์ฌ์ฌ์ฉํ๊ณ ๋์์ฑ์ ์ ํ
A connection pool reuses database connections and bounds database concurrency.
Parameter binding blocks SQL injection and reuses the query plan
ํ๋ผ๋ฏธํฐ ๋ฐ์ธ๋ฉ์ผ๋ก SQL injection ๋ง๊ณ query plan ์ฌ์ฌ์ฉ
PreparedStatement sends a parameterized SQL template with ? placeholders separately from the values, so user input is bound as data โ never parsed as SQL โ which prevents injection and lets the database parse and plan the statement once and reuse it.
A set of principles for designing classes that absorb change
๋ณ๊ฒฝ์ ๊ฐํ ๊ฐ์ฒด ์ค๊ณ ์์น ๋ฌถ์
SOLID is about making object-oriented code easier to change safely.
Keeping high-level policy from depending directly on low-level details
์์ ์ ์ฑ ์ด ํ์ ๊ตฌํ์ ์ง์ ์์กดํ์ง ์๊ฒ ํจ
High-level policy should depend on abstractions, not low-level details.
Assemble behavior by delegating to collaborators (has-a) instead of subclassing (is-a)
์์(is-a) ๋์ ์์(has-a)์ผ๋ก ๋์์ ์กฐ๋ฆฝํ๋ค
Composition over inheritance means you reuse behavior by holding a collaborator and delegating to it, rather than subclassing a base whose implementation you'd be permanently coupled to.
Pulling an algorithm or policy out into a swappable object
์๊ณ ๋ฆฌ์ฆ/์ ์ฑ ์ ๊ต์ฒด ๊ฐ๋ฅํ ๊ฐ์ฒด๋ก ๋ถ๋ฆฌ
Strategy separates interchangeable algorithms behind a common interface.
Hide object creation behind an interface so callers don't depend on concrete classes
๊ฐ์ฒด ์์ฑ์ ์ธํฐํ์ด์ค ๋ค๋ก ์จ๊ฒจ ํธ์ถ๋ถ๊ฐ ๊ตฌ์ฒด ํด๋์ค๋ฅผ ๋ชจ๋ฅด๊ฒ ํ๋ค
A factory centralizes object construction behind an interface so callers depend on the abstraction, not on which concrete class gets instantiated.
Wrap an incompatible vendor interface so your code talks to one stable contract
ํธํ ์ ๋๋ ์ธ๋ถ ์ธํฐํ์ด์ค๋ฅผ ๋ด ํ์ค ์ธํฐํ์ด์ค๋ก ๊ฐ์ธ๊ธฐ
The Adapter pattern wraps a class whose interface you can't change so it conforms to the target interface your code already expects.
Encapsulate per-state behavior in objects so illegal transitions are blocked structurally at runtime
state๋ณ ๋์์ ๊ฐ์ฒด๋ก ์บก์ํํด ๋ถ๋ฒ ์ ์ด๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก(๋ฐํ์์) ๋ง๋๋ค
The State pattern moves each state's behavior into its own object and lets the context delegate to the current state, so transitions are explicit and a state simply doesn't implement the actions it forbids.
Declare valid transitions as data; reject everything else
์ ํจํ ์ํ ์ ์ด๋ฅผ ๋ฐ์ดํฐ๋ก ์ ์ธํ๊ณ , ๋๋จธ์ง๋ ์ ๋ถ ๊ฑฐ๋ถ
Enum + transition table models legal state changes as data in an EnumMap of allowed target states, so a single canTransition gate rejects everything not declared, making illegal transitions structurally impossible instead of scattering rules across if/switch.
Use types and encapsulation so a wrong state can't be built
ํ์ ๊ณผ ์บก์ํ๋ก ์๋ชป๋ ์ํ๋ฅผ ์์ ๋ชป ๋ง๋ค๊ฒ
Make illegal states unrepresentable means designing types so that a wrong state simply can't be constructed: a private constructor plus a validating factory, value objects instead of primitives, and enums instead of strings, so the type itself carries the invariant.
Seams and dependency injection to test logic without a real DB or network
seam๊ณผ ์์กด์ฑ ์ฃผ์ ์ผ๋ก DB/๋คํธ์ํฌ ์์ด ๋ก์ง์ ํ ์คํธํ๊ธฐ
Designing for testability means introducing seams and injecting dependencies โ repositories, the clock, randomness โ so business logic can be exercised with in-memory fakes instead of a real database, network, or wall-clock time.
A pattern is a cost โ abstract only when the seam is real
ํจํด์ ๋น์ฉ์ด๋ค โ seam์ด ์ค์ฌํ ๋๋ง ์ถ์ํ
A pattern buys flexibility along one axis in exchange for indirection, so you only apply it once the variation it abstracts has actually shown up โ not when you merely imagine it might.
Group several DB operations into one logical unit
์ฌ๋ฌ DB ์์ ์ ํ๋์ ๋ ผ๋ฆฌ ๋จ์๋ก ๋ฌถ์
A transaction groups multiple database operations into one reliable unit.
How much concurrent transactions hide from each other
๋์ transaction์ด ์๋ก๋ฅผ ์ผ๋ง๋ ๊ฐ๋ฆฌ๋์ง
Isolation level controls which concurrency anomalies a transaction can observe.
Snapshot isolation where reads and writes don't block each other
์ฝ๊ธฐ์ ์ฐ๊ธฐ๊ฐ ์๋ก ๋ง์ง ์๋ ์ค๋ ์ท ๊ฒฉ๋ฆฌ
MVCC keeps multiple versions of each row so every transaction reads a consistent snapshot, letting readers and writers run concurrently without blocking each other.
Log the change before applying it โ the substrate for crash recovery and replication
๋ฐ๊พธ๊ธฐ ์ ์ ๋จผ์ ๋ก๊ทธ์ ๊ธฐ๋กํ๋ผ โ ์ถฉ๋ ๋ณต๊ตฌ์ ๋ณต์ ์ ๊ธฐ๋ฐ
A write-ahead log forces every change to be appended durably to a sequential log before the corresponding data page is modified, so the log alone can replay (redo) the database to a consistent state after a crash and can be streamed to replicas.
Sorted lookup structure that makes reads fast
์ฝ๊ธฐ๋ฅผ ๋น ๋ฅด๊ฒ ๋ง๋๋ ์ ๋ ฌ๋ ์ ๊ทผ ๊ตฌ์กฐ
An index speeds up reads by maintaining an ordered access path.
The DB's plan for how it'll run your query
DB๊ฐ ์ฟผ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ์คํํ ์ง์ ๊ณํ
A query plan shows how the database will execute a query.
One list query, then an extra query per row
๋ชฉ๋ก ํ๋ ์กฐํ ํ ๊ฐ row๋ง๋ค ์ถ๊ฐ ์ฟผ๋ฆฌ
N+1 means one query for a list plus one extra query per row.
Storing expensive read results close by
๋น์ผ ์ฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ๊น์ด ๊ณณ์ ์ ์ฅ
A cache trades freshness and complexity for lower latency and lower load.
cache-aside is the default; write-through/behind trade consistency for latency
cache-aside๊ฐ ๊ธฐ๋ณธ, write-through/behind๋ ์ ํฉ์ฑ vs ์ง์ฐ ํธ๋ ์ด๋์คํ
Cache write patterns define how reads and writes flow between the cache and the system-of-record database, trading off consistency, write latency, and durability.
A wave of simultaneous misses slamming the DB
๋์์ miss๊ฐ ๋์ DB๋ฅผ ๋๋ฆฌ๋ ํ์
A cache stampede happens when many requests miss the same hot key at once.
Scale reads with replicas, split big tables with partitions, exceed one node with shards
์ฝ๊ธฐ ํ์ฅ์ replica, ํฐ ํ ์ด๋ธ์ partition, ๋จ์ผ ๋ ธ๋ ํ๊ณ๋ sharding
Read replicas scale reads, partitioning splits one table inside one node, and sharding splits data across nodes to scale writes โ reach for them in that order because each adds more operational pain.
Copy the same data to multiple nodes
๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๋ ธ๋์ ๋ณต์
Replication copies data to multiple nodes for availability and read scale.
Split data across multiple partitions
๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ์กฐ๊ฐ์ผ๋ก ๋๋ ์ ์ฅ
Sharding splits data across nodes using a shard key.
Read and write with agreement from enough replicas
์ฌ๋ฌ replica ์ค ์ถฉ๋ถํ ์์ ๋์๋ก ์ฝ๊ณ ์
Quorum uses enough replicas for reads and writes to balance consistency and availability.
Diverges now, converges eventually
๋น์ฅ์ ๋ค๋ฅผ ์ ์์ง๋ง ๊ฒฐ๊ตญ ์๋ ด
Eventual consistency allows temporary divergence as long as replicas converge later.
linearizable to eventual: what each guarantees and what it gives up
linearizable๋ถํฐ eventual๊น์ง: ๋ฌด์์ ๋ณด์ฅํ๊ณ ๋ฌด์์ ํฌ๊ธฐํ๋๊ฐ
A consistency model is the contract a datastore makes about the order and recency of reads and writes โ linearizable means every operation appears to happen instantaneously on one up-to-date copy in real-time order, and weaker models (sequential, causal, eventual) trade that illusion away for lower latency and higher availability.
Time to finish a single request
ํ ์์ฒญ์ด ๋๋ ๋๊น์ง ๊ฑธ๋ฆฌ๋ ์๊ฐ
Latency is the time a single request takes from start to finish.
How much you process per unit of time
๋จ์ ์๊ฐ๋น ์ฒ๋ฆฌ๋
Throughput is how much work the system completes per unit of time.
The fraction of time users can actually succeed
์ฌ์ฉ์๊ฐ ์ฑ๊ณต์ ์ผ๋ก ์ธ ์ ์๋ ๋น์จ
Availability is the percentage of time or requests where the system is usable.
Estimating QPS, storage, and bandwidth in under a minute with powers of ten
QPS, ์ ์ฅ๋, ๋์ญํญ์ 10์ ๊ฑฐ๋ญ์ ๊ณฑ์ผ๋ก 1๋ถ ์์ ์ถ์ ํ๊ธฐ
Back-of-the-envelope estimation is rounding everything to powers of ten and using a few constants โ 86400 seconds a day, peak being 2-3x average, and the read:write ratio โ to turn a daily volume into QPS, storage, and bandwidth, so I can justify an architecture by arithmetic rather than by guess.
One bigger box vs many boxes โ scale up first, shard last
ํฐ ๋ฐ์ค ํ๋ vs ์ฌ๋ฌ ๋ฐ์ค โ scale-up ๋จผ์ , shard ๋ง์ง๋ง
Vertical scaling means a bigger single box โ simple but capped and a single point of failure; horizontal scaling means more boxes โ effectively unbounded but it forces statelessness, a load balancer, and distributed coordination.
Externalize state so any instance can serve any request
์ํ๋ฅผ ๋ฐ์ผ๋ก ๋นผ์ ์๋ฌด ์ธ์คํด์ค๋ ์๋ฌด ์์ฒญ์ ์ฒ๋ฆฌํ๊ฒ
A stateless app tier keeps no per-request state in process memory, so it externalizes session and conversational state to Redis, a DB, or a signed JWT, letting any instance serve any request and enabling horizontal scaling, autoscaling, and zero-downtime deploys.
Spreading traffic across multiple instances
ํธ๋ํฝ์ ์ฌ๋ฌ ์ธ์คํด์ค๋ก ๋ถ์ฐ
A load balancer distributes traffic and removes unhealthy instances.
Capping excessive traffic to protect the system
๊ณผ๋ํ ์์ฒญ์ ์ ํํด ์์คํ ์ ๋ณดํธ
Rate limiting protects the system by bounding request rate per identity.
A time budget for cutting off calls that hang
๋๋์ง ์๋ ํธ์ถ์ ๋๋ ์๊ฐ ์์ฐ
A timeout is a time budget for a dependency call.
Re-attempting a transient failure
์ผ์์ ์คํจ๋ฅผ ๋ค์ ์๋
Retries help with transient failures, but they can amplify an outage.
Briefly cutting off calls to a broken dependency
๋ง๊ฐ์ง dependency ํธ์ถ์ ์ ์ ์ฐจ๋จ
A circuit breaker stops calling a failing dependency to protect the caller.
Pushing back or slowing input you can't keep up with
์ฒ๋ฆฌ ๋ฅ๋ ฅ๋ณด๋ค ๋ง์ ์ ๋ ฅ์ ๋ฐ์ด๋ด๊ฑฐ๋ ๋ฆ์ถค
Backpressure tells upstream producers to slow down when downstream is saturated.
Sending the same request many times but it lands once
๊ฐ์ ์์ฒญ์ ์ฌ๋ฌ ๋ฒ ๋ณด๋ด๋ ๊ฒฐ๊ณผ๊ฐ ํ ๋ฒ์ฒ๋ผ ๋จ
Idempotency means repeated requests produce the same effect as one request.
Pick consistency or availability under a partition
network partition์์ consistency์ availability ์ ํ
Under a network partition, a distributed system must trade consistency against availability.
Four per-client guarantees layered on top of eventual consistency
์ต์ข ์ผ๊ด์ฑ ์์์ ํ ํด๋ผ์ด์ธํธ์๊ฒ๋ง ๋ณด์ฅํ๋ 4๊ฐ์ง ์ผ๊ด์ฑ
Session guarantees are per-client consistency promises layered on eventual consistency โ read-your-writes, monotonic reads, monotonic writes, and consistent prefix โ so a single client never sees its own actions go backwards even when the global store is async-replicated.
A partition can leave two leaders writing at once โ fencing tokens stop the double-write
ํํฐ์ ํ ๋ ๋ฆฌ๋๊ฐ ๋์์ ์ฐ๋ฉด ๋ฐ์ดํฐ๊ฐ ๊นจ์ง๋ค โ fencing token์ผ๋ก ๋ง๋๋ค
Failover auto-promotes a new leader when the old one dies, but a network partition can produce a split-brain with two leaders, so quorum, a monotonically increasing fencing token checked at the storage layer, and STONITH prevent two leaders from double-writing and corrupting data.
One slow dependency takes the whole system down โ and how to stop it
ํ ๊ณณ์ ์ง์ฐ์ด ์ ์ฒด๋ฅผ ๋ฌด๋๋จ๋ฆฌ๋ ์ฐ์ ์ฅ์ ์ ๊ทธ ๋ฐฉ์ด์
A cascading failure is when one slow or failing dependency exhausts upstream resources โ threads, connections โ and client retries amplify the load, so the failure propagates and self-amplifies across the system; you stop it with timeouts, circuit breakers, bulkheads, backpressure/load shedding, and jittered backoff.
A hash ring where adding/removing a node moves only ~1/N keys
๋ ธ๋ ์ถ๊ฐ/์ ๊ฑฐ ์ ~1/N ํค๋ง ์ด๋ํ๋ ํด์ ๋ง
Consistent hashing maps keys and nodes onto one hash ring and assigns each key to the next node clockwise, so adding or removing a node only remaps about 1/N of the keys instead of all of them.
Safely ties a DB write to publishing an event
DB write์ event ๋ฐํ์ ์์ ํ๊ฒ ์ฐ๊ฒฐ
The outbox pattern stores events in the same transaction as the business change.
Keeps consistency with compensating steps instead of a distributed transaction
๋ถ์ฐ transaction ๋์ ๋ณด์ ์์ ์ผ๋ก ์ผ๊ด์ฑ ์ ์ง
A saga coordinates local transactions with compensating actions.
Buffers work asynchronously for workers to process
์์ ์ ๋น๋๊ธฐ๋ก ์๊ณ worker๊ฐ ์ฒ๋ฆฌ
A queue decouples producers from consumers by buffering work.
Logical name for a stream of events
event stream์ ์ ์ฅํ๋ ๋ ผ๋ฆฌ์ ์ด๋ฆ
A Kafka topic is an append-only event log that consumers read independently.
Splitting a topic into parallel log slices
topic์ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๊ฐ๋ฅํ log ์กฐ๊ฐ์ผ๋ก ๋๋
A Kafka partition is an ordered log segment inside a topic.
A group of consumers splitting partitions between them
์ฌ๋ฌ consumer๊ฐ partition์ ๋๋ ์ฝ๋ ๋จ์
A consumer group lets consumers share partitions for parallel processing.
Where a record sits inside a partition
partition ์์์ record ์์น
An offset is the consumer's position in a Kafka partition.
Message delivery guarantees: lose it, dupe it, or process it once
๋ฉ์์ง ์ ๋ฌ ๋ณด์ฅ: ์๊ฑฐ๋, ์ค๋ณต๋๊ฑฐ๋, ์ ํํ ํ ๋ฒ
Delivery semantics describe how many times a message is processed end-to-end: at-most-once may lose, at-least-once may duplicate, and exactly-once is really at-least-once plus deduplication on an idempotency key.
Quarantine for messages that keep failing
๊ณ์ ์คํจํ๋ ๋ฉ์์ง๋ฅผ ๊ฒฉ๋ฆฌ
A dead letter queue isolates messages that repeatedly fail processing.
Managing event formats and compatibility
event ํ์๊ณผ ํธํ์ฑ์ ๊ด๋ฆฌ
A schema registry manages event contracts and compatibility.
Looking up values by key in roughly O(1)
key๋ก ๊ฐ์ ํ๊ท O(1)์ ์ฐพ๋ ์๋ฃ๊ตฌ์กฐ
A hash map maps keys to buckets so lookups are average O(1).
Halving the search range on sorted or monotonic data
์ ๋ ฌ/๋จ์กฐ ์กฐ๊ฑด์์ ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ค์
Binary search halves the search space using sorted order or a monotonic predicate.
Scanning linearly by moving two indices
๋ index๋ฅผ ์์ง์ด๋ฉฐ ์ ํ์ผ๋ก ํ์
Two pointers scan with two indices while maintaining an invariant.
Growing and shrinking a contiguous range to meet a condition
์ฐ์ ๊ตฌ๊ฐ์ ๋๋ฆฌ๊ณ ์ค์ด๋ฉฐ ์กฐ๊ฑด์ ๋ง์กฑ
Sliding window maintains a moving contiguous range.
The basic ways to traverse graphs and trees
๊ทธ๋ํ์ ํธ๋ฆฌ๋ฅผ ํ์ํ๋ ๊ธฐ๋ณธ ๋ฐฉ์
BFS explores level by level; DFS explores one path deeply before backtracking.
Data structure for fast min/max access
์ต์๊ฐ/์ต๋๊ฐ์ ๋น ๋ฅด๊ฒ ๊บผ๋ด๋ ์๋ฃ๊ตฌ์กฐ
A heap keeps the highest-priority item at the top.
Solving by caching overlapping subproblems
์ค๋ณต subproblem์ ์ ์ฅํด์ ํธ๋ ๋ฐฉ์
Dynamic programming stores overlapping subproblems and builds the answer from states.
Linearize a DAG so every edge points forward (Kahn / DFS post-order)
DAG์ ๋ ธ๋๋ฅผ ๋ชจ๋ ๊ฐ์ ์ด ์์ผ๋ก ํฅํ๋๋ก ์ ํ ์ ๋ ฌ (Kahn / DFS post-order)
Topological sort orders a DAG's nodes so every directed edge points forward, and if you can't emit all nodes there's a cycle.
Model status as explicit states, transitions, and guards; reject illegal moves
์ํยท์ ์ดยท๊ฐ๋๋ฅผ ๋ช ์ํด ๋ถ๋ฒ ์ ์ด๋ฅผ ๊ฑฐ๋ถํ๋ ๋ชจ๋ธ
A finite state machine models a process as a fixed set of states with explicitly allowed transitions, terminal states, and guard conditions, rejecting any move that isn't declared.
int/long overflow and the money-precision trap
int/long ์ค๋ฒํ๋ก์ฐ์ ๋ ๊ณ์ฐ ์ ๋ฐ๋ ํจ์
int overflows silently at about ยฑ2.1 billion and double can't represent decimal money exactly, so I compute midpoints as low+(high-low)/2, store money as BigDecimal or integer cents, and use Math.addExact when I need overflow to fail loudly.
One op can be expensive, but averaged over the whole sequence it's cheap
ํ ๋ฒ์ฉ ๋น์ผ ์ฐ์ฐ์ด ๋ผ์ด๋ ์ํ์ค ์ ์ฒด๋ก ํ๊ท ํ๋ฉด ์ธ๋ค
Amortized analysis measures the average cost per operation across a whole sequence, so a rare O(n) resize gets spread thin enough that each push is O(1) amortized.
Get top-K by frequency in O(n) using count buckets instead of sorting
์ ๋ ฌ ์์ด ๋น๋ ๋ฒํท์ผ๋ก top-K๋ฅผ O(n)์ ๋ฝ๊ธฐ
Bucketing gets top-K frequent elements in O(n) by counting frequencies, then indexing a bucket array by count and scanning from the highest count down โ no full sort needed.
From typing the URL to pixels on the screen
URL ์ ๋ ฅ๋ถํฐ ํ๋ฉด ๋ ๋๋ง๊น์ง์ ํฐ ํ๋ฆ
A browser turns navigation into network requests, downloaded assets, parsed code, and rendered UI.
How the browser and server split rendering work
๋ธ๋ผ์ฐ์ ์ ์๋ฒ๊ฐ UI๋ฅผ ๋๋ ๋ ๋๋งํ๋ ๋ฐฉ์
SSR sends initial HTML from the server; hydration attaches client-side behavior to it.
A piece of UI declared from props and state
props์ state๋ก UI ์กฐ๊ฐ์ ์ ์ธ
A React component is a function of props and state that returns UI.
Local memory that triggers a re-render
UI๋ฅผ ๋ค์ ๋ ๋๋งํ๊ฒ ๋ง๋๋ local memory
React state is local UI memory that triggers re-rendering when it changes.
Syncing with external systems after render
render ์ดํ ์ธ๋ถ ์์คํ ๊ณผ ๋๊ธฐํ
useEffect synchronizes a component with an external system after render.
React state owning the form value
form ๊ฐ์ React state๊ฐ ์์
A controlled input is a form field whose value is owned by React state.
Wiring up the API with loading, error, and success states
loading/error/success ์ํ๋ฅผ ๊ด๋ฆฌํ๋ฉฐ API์ ์ฐ๊ฒฐ
Frontend data fetching means modeling loading, error, empty, and success states around an API call.
Connecting the URL to screen state
URL๊ณผ ํ๋ฉด ์ํ๋ฅผ ์ฐ๊ฒฐ
Frontend routing maps URLs to UI state and screens.
Designing for keyboard, screen readers, and semantic HTML
ํค๋ณด๋, screen reader, semantic HTML์ ๊ณ ๋ ค
Accessibility means the UI works with semantic HTML, keyboard navigation, focus, labels, and assistive technology.
Managing bundle, render, network, and interaction latency
bundle, rendering, network, interaction ์ง์ฐ์ ๊ด๋ฆฌ
Frontend performance is about network, bundle size, rendering cost, layout stability, and interaction latency.
Verify user flows with component, integration, and E2E tests
component, integration, E2E๋ก ์ฌ์ฉ์ ํ๋ฆ ๊ฒ์ฆ
Frontend tests should verify user-visible behavior, not just implementation details.
Keeping repeated UI and interaction rules consistent
๋ฐ๋ณต UI์ interaction ๊ท์น์ ์ผ๊ด๋๊ฒ ๊ด๋ฆฌ
A design system keeps UI components, states, spacing, and interaction patterns consistent.
The three signals for observing a system
์์คํ ์ ๊ด์ฐฐํ๋ ์ธ ๊ฐ์ง ์ ํธ
Logs tell events, metrics show trends, and traces show request paths.
The metric that surfaces the slow requests the average hides
ํ๊ท ์ด ์จ๊ธฐ๋ ๋๋ฆฐ ์์ฒญ์ ๋ณด๋ ์งํ
p99 shows the tail: 99 percent of requests are faster than this value.
Putting numbers on the reliability you promise
์๋น์ค ์ ๋ขฐ์ฑ์ ์ซ์๋ก ์ฝ์ํ๋ ๋ฐฉ์
An SLI is what I measure, an SLO is the target, and an SLA is the external promise.
Only alert on signals worth waking someone up for
์ฌ๋์ ๊นจ์์ผ ํ๋ ์ ํธ๋ง ์๋ฆผ
An alert should fire only when a human needs to take action.
Proving who you are vs deciding what you can do
๋๊ตฌ์ธ์ง ํ์ธ vs ๋ฌด์์ ํ ์ ์๋์ง ๊ฒฐ์
Authentication proves identity; authorization decides allowed actions.
A bundle of signed claims you pass around
์๋ช ๋ claim ๋ฌถ์์ผ๋ก ์ ๋ฌ๋๋ token
A JWT is a signed set of claims, not an encrypted secret container.
Delegated access plus a login identity layer
๊ถํ ์์๊ณผ ๋ก๊ทธ์ธ identity layer
OAuth delegates access; OIDC adds identity on top of OAuth.
Two ways to combine branch history
branch history๋ฅผ ํฉ์น๋ ๋ ๋ฐฉ์
Merge preserves branch history; rebase rewrites commits onto a new base.
Multiple branch working folders from one repo at once
ํ repo์์ ์ฌ๋ฌ branch ์์ ํด๋๋ฅผ ๋์์ ์ฌ์ฉ
Git worktree lets one repository have multiple working directories.
Pipeline that automates verification and deploy
๊ฒ์ฆ๊ณผ ๋ฐฐํฌ๋ฅผ ์๋ํํ๋ ํ์ดํ๋ผ์ธ
CI validates every change; CD delivers validated artifacts safely.
Packaging an app and its runtime deps into an image
์ ํ๋ฆฌ์ผ์ด์ ๊ณผ runtime ์์กด์ฑ์ ์ด๋ฏธ์ง๋ก ํจํค์ง
A container packages an application with its runtime dependencies.
The smallest deployable unit in Kubernetes
Kubernetes์์ ๋ฐฐํฌ๋๋ ๊ฐ์ฅ ์์ ์คํ ๋จ์
A pod is the smallest deployable runtime unit in Kubernetes.
Managing pod replicas and rollouts
Pod replica์ rollout์ ๊ด๋ฆฌ
A Deployment manages pod replicas and rolling updates.
Reviewing the infra diff before applying
์ธํ๋ผ ๋ณ๊ฒฝ diff๋ฅผ ๋ณด๊ณ ์ ์ฉ
Terraform plan previews infrastructure changes; apply executes them.
The ledger mapping code to real infra
์ฝ๋์ ์ค์ ์ธํ๋ผ๋ฅผ ๋งคํํ๋ ์ฅ๋ถ
Terraform state maps declared resources to real infrastructure objects.
When code and real infra fall out of sync
์ฝ๋์ ์ค์ ์ธํ๋ผ๊ฐ ๋ฌ๋ผ์ง ์ํ
Drift means real infrastructure no longer matches the Terraform configuration.
The logical network boundary inside AWS
AWS ์์ ๋ ผ๋ฆฌ์ ๋คํธ์ํฌ ๊ฒฝ๊ณ
A VPC is an isolated virtual network for AWS resources.
Controlling who can do what
๋๊ฐ ๋ฌด์์ ํ ์ ์๋์ง ๊ถํ ๊ด๋ฆฌ
IAM controls who can perform which actions on which AWS resources.
A fixed test for comparing performance
์ฑ๋ฅ ๋น๊ต๋ฅผ ์ํ ๊ณ ์ ํ ์คํธ
A benchmark is a standardized test, not automatically proof of real-world performance.
The current or simple approach you compare against
๋น๊ต ๊ธฐ์ค์ด ๋๋ ํ์ฌ/๋จ์ ๋ฐฉ๋ฒ
A baseline is the reference point I compare against.
State of the art โ the claim that it's the current best
State of the art, ํ์ฌ ์ต๊ณ ์์ค์ด๋ผ๋ ์ฃผ์ฅ
SOTA means state of the art, but I should ask: on what benchmark and under what conditions?
Claiming it can handle growing load
๋ถํ ์ฆ๊ฐ๋ฅผ ๊ฐ๋นํ ์ ์๋ค๋ ์ฃผ์ฅ
Scalable means the system can handle more load by adding the right resources.
Claiming it's ready to run in production
์ด์ ํ๊ฒฝ์์ ์ธ ์ค๋น๊ฐ ๋๋ค๋ ์ฃผ์ฅ
Production-ready means it can be operated safely, not just demoed.
Claiming it responds almost instantly
๊ฑฐ์ ์ฆ์ ๋ฐ์ํ๋ค๋ ์ฃผ์ฅ
Real-time only means something when I define the latency budget and correctness requirement.
Full path from user action to final result
์ฌ์ฉ์ ์์๋ถํฐ ์ต์ข ๊ฒฐ๊ณผ๊น์ง ์ ์ฒด ํ๋ฆ
End-to-end means from the user's starting point to the final outcome.
Acting like a goal-driven agent
agent์ฒ๋ผ ๋ชฉํ ์งํฅ์ ์ผ๋ก ํ๋ํ๋ค๋ ํํ
Agentic should mean goal-directed behavior with tools, state, and control gates.
Handling images, audio, or video alongside text
ํ ์คํธ ์ธ ์ด๋ฏธ์ง/์์ฑ/๋น๋์ค ๋ฑ์ ํจ๊ป ๋ค๋ฃธ
Multimodal means the system can work across input or output types like text, image, audio, or video.
Doing the task with no examples
์์ ์์ด ๋ฐ๋ก ์ํ
Zero-shot means asking the model to perform a task without examples.
AI that assists, user stays in control
์ฌ์ฉ์๋ฅผ ๋ณด์กฐํ๋ AI ๊ธฐ๋ฅ
A copilot assists the user inside a workflow; it does not automatically own the whole outcome.
๊ฒ์์ด๋ฅผ ์ค์ด๊ฑฐ๋ All ํํฐ๋ก ๋์๊ฐ๋ผ.