Side by side
The terms people mix up, compared
151 comparisons, each laid out like two facing pages: what each term is, how they differ, and when to pick which.
The ones people ask about most
- SQLNoSQLSQL vs NoSQLSQL databases keep data in related tables with a fixed schema, while NoSQL databases use flexible models like documents or key-value pairs that scale out.7 differences
- REST APIGraphQLREST vs GraphQLREST exposes many URLs that each return a fixed shape of data, while GraphQL exposes a single endpoint where the client asks for exactly the fields it needs.7 differences
- TCPUDPTCP vs UDPTCP opens a connection and guarantees complete, in-order delivery, while UDP sends independent packets with no guarantee, trading reliability for lower latency.7 differences
- MergeRebaseGit Merge vs RebaseGit merge joins two branches with a merge commit that keeps the full history, while git rebase replays your commits onto another branch for a linear history.7 differences
- DockerKubernetesDocker vs KubernetesDocker builds container images and runs containers on one machine, while Kubernetes runs them across a cluster, handling scheduling, scaling and self-healing.8 differences
- AuthenticationAuthorizationAuthentication vs AuthorizationAuthentication verifies who you are, for example with a password or passkey, while authorization decides what you are allowed to do once your identity is known.7 differences
Every comparison, by book
Programming Fundamentals12 comparisons
- CompilervsInterpreterA compiler translates a whole program before it runs, while an interpreter executes source code step by step at runtime, trading raw speed for faster feedback.
- OOPvsFunctional ProgrammingOOP bundles data and the methods that change it into objects, while functional programming transforms immutable data with pure functions.
- ArrayvsLinked ListAn array keeps elements side by side in memory, so any item is read instantly by index; a linked list chains nodes with pointers: cheap inserts, slow lookups.
- CallbackvsPromiseA callback is a function you hand to another function to run when it's done, while a promise stands for a future result you can chain and catch errors on.
- CompilervsTranspilerA compiler turns code into a lower-level form a machine or VM runs, while a transpiler outputs another high-level language, like TypeScript to JavaScript.
- LibraryvsFrameworkA library is code you call when you need it, while a framework provides your app's structure and calls your code. You call a library; a framework calls you.
- Static TypingvsDynamic TypingStatic typing checks types before the program runs, usually with a compiler, while dynamic typing attaches types to values and checks them only at run time.
- ConcurrencyvsParallelismConcurrency is handling many tasks in overlapping time, even on one core, while parallelism is running several tasks at the same instant on multiple cores.
- ClassvsObjectA class is a blueprint that describes what data and behavior a kind of thing has, while an object is one concrete thing built from it, with its own values.
- PromisevsAsync/AwaitA promise is an object for a value that arrives later; async/await is syntax built on promises that lets you wait for them in step-by-step code.
- Abstract ClassvsInterfaceAn abstract class shares code and state with its subclasses; an interface only declares what a type can do, and a class can implement many.
- CompositionvsInheritanceComposition reuses code by holding other objects and delegating to them (has-a); inheritance reuses it by extending a parent class (is-a).
Web Development26 comparisons
- JavaScriptvsTypeScriptJavaScript is the dynamically typed language that browsers and Node.js run, while TypeScript is a superset that adds static types and compiles to JavaScript.
- SSRvsCSRServer-side rendering (SSR) builds full HTML on the server for each request, so content shows fast, while CSR builds the page in the browser with JavaScript.
- SSGvsSSRSSG builds each page into HTML once, at build time, and serves the same file to everyone, while SSR builds the HTML on every request, so it can show fresh data.
- CookievsLocal StorageCookies are small data the browser sends to the server with every matching request, while local storage keeps larger data in the browser and never sends it.
- DOMvsVirtual DOMThe DOM is the browser's live tree of page elements, while the virtual DOM is a light JavaScript copy that frameworks compare to decide what to change.
- CSS GridvsFlexboxCSS Grid places items in rows and columns at once, in two dimensions, while Flexbox lines them up along one row or column, ideal inside components.
- CookievsSessionA cookie is small data the browser stores and sends back with each request, while a session is state the server keeps about a visitor, found by a cookie ID.
- ReactvsVueReact is a library that uses JSX and leaves routing and state to its ecosystem, while Vue is a framework with HTML-like templates and official tools for both.
- ReactvsAngularReact is Meta's flexible UI library that you pair with other tools, while Angular is Google's opinionated framework with routing, forms and HTTP built in.
- Next.jsvsReactReact is a library for building UIs from components, while Next.js is a React framework that adds routing, server-side rendering and static generation.
- VitevsWebpackWebpack bundles the whole app before serving it, even in development, while Vite serves native ES modules and bundles only for production, so it starts fast.
- FrontendvsBackendThe frontend runs on the user's device and draws the interface, while the backend runs on servers and holds the data and rules the frontend relies on.
- DebouncevsThrottlingDebounce waits until a burst of events stops, then runs the function once, while throttle runs it at most once per interval as the events continue.
- ReactvsSvelteReact updates the page at runtime by comparing a virtual DOM, while Svelte compiles components ahead of time into code that updates the DOM directly.
- VuevsAngularVue is a lightweight, progressive framework you can adopt step by step; Angular is a complete, opinionated TypeScript framework with everything built in.
- npmvsYarnnpm ships with Node.js and installs into node_modules; Yarn is a separate client for the same registry, with its own lockfile and Plug'n'Play installs.
- npmvspnpmnpm copies every package into each project's flat node_modules; pnpm keeps one copy in a shared store, links it in and blocks undeclared imports.
- Tailwind CSSvsBootstrapTailwind CSS gives you small utility classes to build your own design; Bootstrap gives you ready-made components with a recognizable default look.
- Next.jsvsAstroNext.js is a React framework for full web applications; Astro is built for content sites and sends JavaScript only for interactive islands.
- Local StoragevsSession StorageBoth store strings by key with the same API; localStorage keeps data for every tab until deleted, while sessionStorage keeps it for one tab until it closes.
- IndexedDBvsLocal StoragelocalStorage is a small, synchronous store of strings; IndexedDB is an asynchronous browser database for large structured data and files.
- Shadow DOMvsVirtual DOMThey solve different problems: the shadow DOM isolates a component's markup and styles, while the virtual DOM helps libraries re-render the page efficiently.
- SPAvsMPAAn SPA loads one page and redraws it with JavaScript as you navigate; an MPA loads a new HTML page from the server on every link or form submission.
- WebSocketvsServer-Sent EventsWebSocket opens a two-way channel where client and server both send messages anytime, while Server-Sent Events (SSE) let only the server push updates.
- HTTPvsHTTPSHTTPS is HTTP sent over encrypted TLS: the requests are the same, but HTTPS hides them from eavesdroppers, detects tampering and proves the server's identity.
- HTTPvsWebSocketHTTP is request-response: the client asks and the server answers once. WebSocket keeps one connection open so both sides can send messages at any time.
Backend & APIs14 comparisons
- DjangovsFlaskDjango is a full-featured Python framework with an ORM, admin panel and authentication built in, while Flask is a minimal one that leaves those choices to you.
- APIvsSDKAn API is the set of requests or functions a service offers, while an SDK is a toolkit, usually built on that API, that makes it easier to use from a language.
- Node.jsvsDenoBoth run JavaScript on V8; Node.js gives scripts full access and has the largest ecosystem, while Deno runs TypeScript directly and asks for permissions.
- Node.jsvsBunNode.js is the long-standing JavaScript runtime built on V8; Bun is a faster-starting runtime on JavaScriptCore that also installs, tests and bundles code.
- REST APIvsGraphQLREST exposes many URLs that each return a fixed shape of data, while GraphQL exposes a single endpoint where the client asks for exactly the fields it needs.
- REST APIvsgRPCREST exposes resources over HTTP, usually as JSON, while gRPC calls typed remote functions with binary messages over HTTP/2: faster, but harder from browsers.
- REST APIvsSOAPREST is a lightweight API style on plain HTTP, URLs and usually JSON, while SOAP is a formal protocol that wraps messages in XML under a strict WSDL contract.
- Message QueuevsPub/SubIn a message queue each message goes to one consumer, so workers share the load, while pub/sub copies every message to each subscriber so many services react.
- API GatewayvsLoad BalancerA load balancer spreads traffic across copies of one service, while an API gateway is one front door that routes calls to the right service and checks auth.
- KafkavsRabbitMQKafka is a streaming platform that keeps events in a durable, replayable log, while RabbitMQ routes messages to queues and deletes them once acknowledged.
- JSONvsXMLBoth write structured data as text: JSON is lighter and maps onto objects and arrays, while XML adds attributes, namespaces and schemas.
- gRPCvsGraphQLgRPC calls typed remote methods with binary Protobuf messages over HTTP/2; GraphQL lets clients query exactly the JSON fields they need from one endpoint.
- APIvsWebhookWith an API, your app sends a request whenever it wants data; with a webhook, another service sends a request to your URL as soon as an event happens.
- Web ServervsApplication ServerA web server handles HTTP connections and serves static files; an application server runs your code to build dynamic responses, usually behind the web server.
Databases11 comparisons
- SQLvsNoSQLSQL databases keep data in related tables with a fixed schema, while NoSQL databases use flexible models like documents or key-value pairs that scale out.
- ShardingvsDatabase ReplicationSharding splits a database so each server stores only part of the data, while replication copies the same data to several servers for redundancy and reads.
- Data WarehousevsData LakeA data warehouse stores cleaned, structured data in a fixed schema for fast queries, while a data lake keeps raw data of any type and adds structure on read.
- PostgreSQLvsMySQLBoth are open-source relational databases: PostgreSQL is known for advanced SQL, extensibility and strictness, MySQL for simplicity, speed and wide adoption.
- OLTPvsOLAPOLTP systems handle many small, fast transactions such as orders and payments, while OLAP systems run large analytical queries over historical data.
- FirebasevsSupabaseBoth give apps a ready-made backend: Firebase is Google's platform built on NoSQL, while Supabase is an open-source alternative built on PostgreSQL.
- MongoDBvsPostgreSQLPostgreSQL keeps data in fixed-schema tables and joins them with SQL, while MongoDB stores flexible JSON-like documents and was built to shard across servers.
- SQLitevsPostgreSQLSQLite is a database library that keeps everything in one file inside your app; PostgreSQL is a database server that many clients use over the network.
- RedisvsMemcachedBoth keep data in memory; Memcached is a plain, multithreaded cache, while Redis adds data structures, persistence, replication and messaging.
- ACIDvsBASEACID makes every transaction correct and visible at once; BASE lets replicas briefly disagree so the system stays available and scales across servers.
- ETLvsELTETL transforms data on a separate system and loads only clean results; ELT loads raw data into the warehouse first and transforms it there, usually with SQL.
DevOps & Cloud17 comparisons
- ContainervsVirtual MachineA container packages an app with its dependencies and shares the host's kernel, while a virtual machine runs its own OS: stronger isolation, more resources.
- DockervsKubernetesDocker builds container images and runs containers on one machine, while Kubernetes runs them across a cluster, handling scheduling, scaling and self-healing.
- Blue-Green DeploymentvsCanary DeploymentBlue-green runs two full environments and switches all traffic to the new one at once, while canary sends a small share to the new version first and grows it.
- Reverse ProxyvsLoad BalancerA reverse proxy forwards requests to the servers behind it and adds TLS, caching and security, while a load balancer spreads load so no server is overloaded.
- DevOpsvsSite Reliability EngineeringDevOps is a culture that unites development and operations to ship faster and safer; SRE is Google's practice of running production to reliability targets.
- TerraformvsAnsibleTerraform declares and creates cloud infrastructure and tracks it in a state file, while Ansible configures existing machines and deploys software over SSH.
- AWSvsAzureAWS is Amazon's cloud, the oldest and largest with the most services, while Azure is Microsoft's, strongest where companies already use Microsoft products.
- Docker ComposevsKubernetesDocker Compose runs a multi-container app on a single machine, while Kubernetes orchestrates containers across a cluster with scaling and self-healing.
- IaaSvsPaaSIaaS rents you raw infrastructure like virtual machines that you manage yourself, while PaaS runs your code and handles the servers, OS and scaling for you.
- SLAvsSLOAn SLO is an internal target, like 99.9% of requests succeeding in 30 days; an SLA promises customers a service level, usually with credits if it is missed.
- AWSvsGoogle CloudBoth are full public clouds. AWS has the broadest catalog and ecosystem; Google Cloud is known for data analytics, AI, Kubernetes and its global network.
- JenkinsvsGitHub ActionsJenkins is an open-source automation server you host and extend with plugins; GitHub Actions is CI/CD built into GitHub, with YAML workflows and hosted runners.
- Docker ImagevsContainerA Docker image is a read-only template holding an app and its dependencies; a container is a running instance of that image with its own writable layer.
- KubernetesvsDocker SwarmBoth run containers across a cluster; Docker Swarm is built into Docker and simple to operate, while Kubernetes does far more at the cost of complexity.
- ServerlessvsContainerServerless runs your code on demand on servers the provider manages; containers package your app with its dependencies to run anywhere, under your control.
- TerraformvsPulumiTerraform describes infrastructure in its own configuration language, HCL; Pulumi describes the same resources in languages such as TypeScript or Python.
- Continuous IntegrationvsContinuous DeliveryCI merges and tests every change on the main branch automatically; CD keeps each tested build ready to release, and continuous deployment releases it.
Version Control7 comparisons
- MergevsRebaseGit merge joins two branches with a merge commit that keeps the full history, while git rebase replays your commits onto another branch for a linear history.
- ForkvsBranchA fork is a full copy of a repository under another owner, used to contribute where you can't push, while a branch is a separate line of work in the same repo.
- Git ResetvsGit RevertGit reset moves a branch back to an earlier commit and drops the later ones, while git revert adds a new commit that undoes one, safe on shared branches.
- GitvsGitHubGit is a version control tool that keeps your code's history on your computer, while GitHub hosts Git repositories online and adds pull requests, issues and CI.
- Git FetchvsGit Pullgit fetch downloads new commits without touching your work, while git pull fetches and then immediately merges or rebases them into your current branch.
- MergevsSquash MergeA regular merge keeps every commit from a branch and joins it with a merge commit; a squash merge folds all of the branch's commits into one new commit.
- MonorepovsPolyrepoA monorepo keeps many projects in one repository so they can change together; a polyrepo gives each project its own repository, history and release cycle.
Security12 comparisons
- AuthenticationvsAuthorizationAuthentication verifies who you are, for example with a password or passkey, while authorization decides what you are allowed to do once your identity is known.
- EncryptionvsHashingEncryption scrambles data with a key so it can be decrypted later, while hashing makes a fixed-length fingerprint that can't be reversed, ideal for passwords.
- JWTvsSessionA JWT is a signed token that carries the user's identity, so servers verify it without a lookup, while sessions keep state on the server behind a random ID.
- XSSvsCSRFXSS injects malicious scripts that run inside a trusted website, while CSRF tricks a logged-in user's browser into sending unwanted requests to that site.
- SQL InjectionvsXSSSQL injection makes a server run an attacker's database commands, while XSS makes a website run an attacker's JavaScript in other users' browsers.
- OAuthvsSSOOAuth lets an app reach a user's data on another service without their password, while SSO is one login for many apps, built on SAML or OpenID Connect.
- OAuthvsOpenID ConnectOAuth 2.0 lets an app access an API for a user with an access token; OpenID Connect adds an identity layer that says who the user is with a signed ID token.
- Symmetric EncryptionvsPublic-Key CryptographySymmetric encryption uses one shared secret key and is fast, while asymmetric uses a public and a private key, which solves key sharing but is much slower.
- JWTvsOAuthOAuth is a framework for giving an app limited access to user data; a JWT is a token format. They aren't rivals: OAuth often issues JWT access tokens.
- SAMLvsOpenID ConnectBoth provide single sign-on. SAML sends signed XML assertions through the browser; OpenID Connect builds on OAuth 2.0 and issues a signed JSON ID token.
- SSLvsTLSSSL is the old, insecure predecessor of TLS and survives only as a name; every so-called SSL connection today really uses TLS 1.2 or 1.3.
- RBACvsABACRBAC grants permissions through roles such as admin or editor; ABAC decides each request from attributes of the user, the resource, the action and the context.
AI & Machine Learning11 comparisons
- Machine LearningvsDeep LearningMachine learning covers algorithms that learn from data; deep learning is a subset whose many-layered neural networks find features alone but need more data.
- RAGvsFine-tuningRAG gives a language model relevant documents at question time so it answers from fresh sources, while fine-tuning trains it further to change its behavior.
- Supervised LearningvsUnsupervised LearningSupervised learning trains a model on labeled examples so it can predict answers for new data, while unsupervised learning finds patterns in unlabeled data.
- Artificial IntelligencevsMachine LearningAI aims to make machines do tasks that need human intelligence; machine learning is one way to get there, learning from data instead of hand-written rules.
- ChatbotvsAI AgentA chatbot converses and answers questions, while an AI agent pursues a goal on its own, planning steps and using tools such as search, code execution or APIs.
- Prompt EngineeringvsFine-tuningPrompt engineering changes the instructions sent with each request and leaves the model as it is; fine-tuning trains the model further so its weights change.
- Generative AIvsLLMGenerative AI is any AI that creates new content, such as text, images, audio or video. An LLM is one kind of generative AI, specialized in text and code.
- Model Context ProtocolvsAPIAn API is any interface programs call to use a service; MCP is an open standard for connecting AI apps to tools and data, and its servers often wrap APIs.
- LLMvsSmall Language ModelAn SLM works like an LLM with far fewer parameters: cheaper, faster and able to run on a laptop or phone, while large models know more and reason better.
- ClassificationvsRegressionClassification predicts a category, such as spam or not spam; regression predicts a number, such as a price or a delivery time. Both are supervised learning.
- OverfittingvsUnderfittingAn overfit model memorizes its training data, noise included, and fails on new data; an underfit model is too simple to learn the pattern and fails on both.
Software Architecture4 comparisons
- MonolithvsMicroservicesA monolith is one app deployed as a single unit, simple to build and run, while microservices split it into small services that deploy and scale independently.
- MVCvsMVVMMVC splits an app into a model, a view and a controller that handles input, while MVVM puts a ViewModel between model and view and syncs them by data binding.
- MicroservicesvsService-Oriented ArchitectureSOA splits enterprise systems into shared services that talk over a central bus, while microservices split one app into small, independently deployed services.
- Horizontal ScalingvsVertical ScalingHorizontal scaling adds more machines and spreads the load across them, while vertical scaling gives one machine more CPU, memory or faster storage.
Testing & Quality7 comparisons
- Unit TestvsIntegration TestA unit test checks one small piece of code, like a function, in isolation within milliseconds; an integration test checks that several parts work together.
- Test-Driven DevelopmentvsBehavior-Driven DevelopmentIn TDD, developers write a failing test before the code that makes it pass, while BDD builds on it with plain-language scenarios the whole team can read.
- Black-Box TestingvsWhite-Box TestingBlack-box testing checks software against its requirements without looking at the code, while white-box testing bases tests on the code's internal structure.
- CypressvsPlaywrightCypress runs end-to-end tests inside the browser with an interactive runner, while Microsoft's Playwright drives browsers from outside, in several languages.
- Integration TestvsEnd-to-End TestAn integration test checks that a few components work together, such as code and a database; an end-to-end test runs a full user journey through the whole app.
- MockingvsTest StubA stub returns canned answers so the code under test can run; a mock also checks how it was called, so the test fails if the expected calls didn't happen.
- LintingvsCode FormatterA linter analyzes code for likely bugs and risky patterns and reports them; a formatter only rewrites layout, such as indentation and line breaks.
Networking8 comparisons
- TCPvsUDPTCP opens a connection and guarantees complete, in-order delivery, while UDP sends independent packets with no guarantee, trading reliability for lower latency.
- LANvsWANA LAN connects devices in one building or site over fast, private links, while a WAN links networks across cities or countries, often over the internet.
- VPNvsProxy ServerA VPN encrypts all your device's traffic and sends it through a secure tunnel, while a proxy forwards only the traffic of apps set to use it, often unencrypted.
- IPv4vsIPv6IPv4 uses 32-bit addresses, allowing about 4.3 billion of them, while IPv6 uses 128-bit addresses, enough for every device to have its own public address.
- LatencyvsThroughputLatency is how long one request or piece of data takes to arrive, while throughput is how much data or how many requests a system handles per unit of time.
- Proxy ServervsReverse ProxyA forward proxy sits in front of clients and sends their requests to the internet; a reverse proxy sits in front of servers and takes requests for them.
- TCPvsHTTPTCP delivers a reliable stream of bytes between two programs; HTTP runs on top of it and gives those bytes meaning as requests and responses.
- HTTP/2vsHTTP/3Both send many requests over one connection; HTTP/2 runs on TCP, where one lost packet stalls every stream, while HTTP/3 runs on QUIC over UDP.
Data Structures3 comparisons
- StackvsQueueA stack removes the newest item first (last in, first out, LIFO), while a queue removes the oldest first (first in, first out, FIFO), like plates versus a line.
- Breadth-First SearchvsDepth-First SearchBFS explores a graph level by level with a queue, finding shortest paths in unweighted graphs, while DFS goes deep down one branch, then backtracks.
- Merge SortvsQuicksortMerge sort guarantees O(n log n) time but uses extra memory, while quicksort partitions around a pivot in place and is usually faster, but can slow to O(n²).
Operating Systems7 comparisons
- ThreadvsCoroutineThe operating system schedules threads and can interrupt them at any moment; coroutines pause only where they choose, so thousands can share one thread.
- ProcessvsThreadA process is a running program with its own memory, while threads run inside a process and share its memory: lighter, but harder to coordinate safely.
- MutexvsSemaphoreA mutex lets one thread at a time use a shared resource and only its owner releases it, while a semaphore is a counter that lets up to N threads in at once.
- Stack MemoryvsHeap MemoryThe stack manages function calls' local variables automatically in last-in, first-out order, fast but small; the heap holds runtime data, larger but slower.
- CPUvsGPUA CPU has a few powerful cores for varied, sequential work; a GPU has thousands of simpler cores that run one operation on lots of data in parallel.
- TerminalvsShellA terminal is the program that shows a text interface and passes on your keystrokes, while the shell runs inside it, reading your commands and executing them.
- GPUvsTPUA GPU is a general parallel processor for graphics and AI, sold by several vendors; a TPU is Google's chip for neural network math, rented on Google Cloud.
Programming Languages9 comparisons
- GovsRustGo is a simple, garbage-collected language for building network services fast, while Rust gets memory safety without a garbage collector, through ownership.
- PythonvsJavaScriptPython is a general-purpose language known for readable code and its data and AI libraries, while JavaScript is the web's language, run by browsers and Node.js.
- PythonvsJavaPython is a concise, dynamically typed language popular for data, AI and scripting, while Java is a statically typed JVM language for enterprise and Android.
- CvsC++C is a small, procedural systems language from the early 1970s; C++ grew out of it into a much larger language with classes, templates and a rich library.
- JavavsJavaScriptJava is a statically typed language compiled to bytecode for the JVM; JavaScript is a dynamically typed language that runs in browsers and on Node.js.
- JavavsKotlinJava is the original JVM language, stable and everywhere; Kotlin is a newer, more concise JVM language with built-in null safety, preferred for Android.
- C#vsJavaC# and Java are similar statically typed, garbage-collected languages; C# runs on Microsoft's .NET, Java on the JVM, and each has its own ecosystem.
- GovsPythonGo is a compiled, statically typed language built for fast, concurrent services; Python is an interpreted, dynamically typed language that leads in data and AI.
- PythonvsRPython is a general-purpose language with strong data and AI libraries; R is a language built for statistics, data analysis and charts, popular in research.
Teams & Process3 comparisons
- AgilevsWaterfallAgile ships working software in short cycles and adapts the plan to feedback, while Waterfall moves through fixed phases from requirements to release.
- ScrumvsKanbanScrum organizes work into fixed-length sprints with set roles and goals, while Kanban is a continuous flow on a board that limits how much work is in progress.
- AgilevsScrumAgile is a set of values for building software in small, frequent steps with feedback, while Scrum is one framework that applies it with roles and sprints.