Side by side
The terms people mix up, compared
98 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 store data in tables with a fixed schema and relationships, while NoSQL databases use flexible models like documents, key-value pairs or graphs that are designed to scale out across many servers.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, often in one request.7 differences
- TCPUDPTCP vs UDPTCP opens a connection and guarantees that data arrives complete and in order, while UDP sends independent packets with no delivery guarantee, trading reliability for lower latency and overhead.7 differences
- MergeRebaseGit Merge vs RebaseGit merge combines two branches by creating a new merge commit that preserves the full history, while git rebase moves your commits on top of another branch, rewriting them to produce a clean, linear history.7 differences
- DockerKubernetesDocker vs KubernetesDocker builds container images and runs containers on a single machine, while Kubernetes orchestrates containers across a cluster of machines, handling scheduling, scaling, networking and self-healing.8 differences
- AuthenticationAuthorizationAuthentication vs AuthorizationAuthentication verifies who you are, for example with a password or a passkey, while authorization decides what you are allowed to do once your identity is known, such as reading a file or deleting a user.7 differences
Every comparison, by book
Programming Fundamentals9 comparisons
- CompilervsInterpreterA compiler translates a whole program into machine code or another form before it runs, while an interpreter reads and executes the source code step by step at runtime, trading raw speed for faster feedback and portability.
- OOPvsFunctional ProgrammingObject-oriented programming organizes code into objects that bundle data with the methods that change it, while functional programming builds programs from pure functions that transform immutable data without side effects.
- ArrayvsLinked ListAn array stores elements next to each other in memory, so any item can be read instantly by its index, while a linked list stores separate nodes connected by pointers, making inserts and deletes cheap but lookups slow.
- CallbackvsPromiseA callback is a function you pass to another function to be called when its work is done, while a promise is an object that stands for a future result and lets you chain steps and handle errors in one place.
- CompilervsTranspilerA compiler translates source code into a lower-level form that a machine or virtual machine can run, while a transpiler translates code into another high-level language at a similar level, such as TypeScript into JavaScript.
- LibraryvsFrameworkA library is code you call when you need it, while a framework provides the structure of your application and calls your code at the right moments; in short, you call a library, but a framework calls you.
- Static TypingvsDynamic TypingIn static typing, types are checked before the program runs, usually by a compiler, while in dynamic typing, types belong to values and are checked only as the program runs.
- ConcurrencyvsParallelismConcurrency is structuring a program to deal with many tasks in overlapping time, possibly on one core by switching between them, while parallelism is actually executing 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; an object is one concrete thing built from that blueprint, with its own values.
Web Development15 comparisons
- JavaScriptvsTypeScriptJavaScript is the dynamically typed language that browsers and Node.js run directly, while TypeScript is a superset of JavaScript that adds static types, checks them before the code runs and then compiles to plain JavaScript.
- SSRvsCSRWith server-side rendering (SSR), the server builds the full HTML for each request so content appears quickly, while with client-side rendering (CSR), the browser downloads JavaScript that builds the page after it loads.
- SSGvsSSRStatic site generation (SSG) builds each page into HTML once, at build time, and serves the same file to everyone, while server-side rendering (SSR) builds the HTML on every request, so it can show fresh or personalized data.
- CookievsLocal StorageCookies are small pieces of data that the browser sends to the server with every matching request, while local storage keeps larger data in the browser only, readable by JavaScript and never sent to the server automatically.
- DOMvsVirtual DOMThe DOM is the browser's live tree of page elements that users see, while the virtual DOM is a lightweight copy kept in JavaScript that frameworks compare between renders to decide which real DOM changes to make.
- CSS GridvsFlexboxCSS Grid lays out items in two dimensions, rows and columns at the same time, while Flexbox arranges items along a single row or column, which makes it ideal for spacing and aligning elements inside components.
- CookievsSessionA cookie is a small piece of data the browser stores and sends back with every request to a site, while a session is the state a server keeps about one visitor, usually found again through a session ID stored in a cookie.
- ReactvsVueReact is a JavaScript library from Meta that describes interfaces with JSX and leaves routing and state to its ecosystem, while Vue is a progressive framework that uses HTML-like templates and ships official tools for routing and state.
- ReactvsAngularReact is a flexible UI library from Meta that you combine with other tools, while Angular is a complete, opinionated framework from Google with routing, forms, HTTP and dependency injection built in.
- Next.jsvsReactReact is a library for building user interfaces from components, while Next.js is a framework built on React that adds routing, server-side rendering, static generation, data loading and an optimized build.
- VitevsWebpackWebpack bundles the whole application before serving it, even during development, while Vite serves source files to the browser as native ES modules in development and bundles only for production, so it starts almost instantly.
- FrontendvsBackendThe frontend is the part of an application that runs on the user's device and draws the interface; the backend runs on servers and holds the data and the rules the frontend relies on.
- DebouncevsThrottlingDebounce waits until a burst of events stops and then runs the function once; throttle runs it at a steady pace, at most once per interval, while the events continue.
- WebSocketvsServer-Sent EventsWebSocket opens a two-way channel where the client and the server can both send messages at any time, while Server-Sent Events (SSE) keep a one-way HTTP stream that only lets the server push text updates to the browser.
- HTTPvsHTTPSHTTPS is HTTP sent over an encrypted TLS connection: the requests and responses are the same, but HTTPS hides them from eavesdroppers, detects tampering and proves the server's identity with a certificate.
Backend & APIs9 comparisons
- DjangovsFlaskDjango is a full-featured Python web framework with an ORM, admin panel, authentication and project structure built in, while Flask is a lightweight microframework that leaves those choices to you.
- APIvsSDKAn API is the interface a service or library offers, the set of requests or functions you can use; an SDK is a toolkit, usually built on that API, that makes using it easier in one language.
- 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, often in one request.
- REST APIvsgRPCREST exposes resources over HTTP, usually as readable JSON, while gRPC calls typed remote functions defined in Protocol Buffers and sends compact binary messages over HTTP/2, which is faster but harder to use from browsers.
- REST APIvsSOAPREST is a lightweight style for web APIs built on plain HTTP, URLs and usually JSON, while SOAP is a formal protocol that wraps every message in an XML envelope and describes services with a strict WSDL contract.
- Message QueuevsPub/SubIn a message queue each message goes to exactly one consumer, so workers share the load, while in pub/sub each message is copied to every subscriber, so many services can react to the same event.
- API GatewayvsLoad BalancerA load balancer spreads incoming traffic across several copies of the same service so that none is overloaded, while an API gateway is a single front door that sends each API call to the right service and applies shared rules such as authentication and rate limits.
- KafkavsRabbitMQKafka is a distributed event streaming platform that keeps events in a durable, replayable log, while RabbitMQ is a message broker that routes individual messages to queues and removes them once consumers acknowledge them.
- JSONvsXMLJSON and XML both write structured data as text. JSON is lighter and maps straight onto the objects and arrays of most languages; XML adds attributes, namespaces and schemas for documents and strict contracts.
Databases7 comparisons
- SQLvsNoSQLSQL databases store data in tables with a fixed schema and relationships, while NoSQL databases use flexible models like documents, key-value pairs or graphs that are designed to scale out across many servers.
- ShardingvsDatabase ReplicationSharding splits a database into pieces so each server stores only part of the data, while replication copies the same data to several servers for redundancy and extra read capacity.
- Data WarehousevsData LakeA data warehouse stores cleaned, structured data in a predefined schema for fast business queries, while a data lake stores raw data of any type in cheap storage and applies structure only when the data is read.
- PostgreSQLvsMySQLPostgreSQL is an open-source relational database known for advanced SQL features, extensibility and strict correctness, while MySQL is an open-source relational database known for simplicity, speed for common web workloads and very wide adoption.
- OLTPvsOLAPOLTP systems handle many small, fast transactions from everyday operations, such as orders and payments, while OLAP systems run large analytical queries over historical data, such as sales trends by region and month.
- FirebasevsSupabaseFirebase is Google's backend platform built around NoSQL document databases, while Supabase is an open-source alternative built on PostgreSQL; both give apps authentication, storage, real-time data and serverless functions without running a backend.
- MongoDBvsPostgreSQLPostgreSQL is a relational database that keeps data in tables with a fixed schema and joins them with SQL; MongoDB is a document database that stores flexible JSON-like documents and was built to shard across servers.
DevOps & Cloud10 comparisons
- ContainervsVirtual MachineA container packages an app and its dependencies and shares the host's operating system kernel, while a virtual machine emulates a whole computer with its own OS, which gives stronger isolation but uses more resources.
- DockervsKubernetesDocker builds container images and runs containers on a single machine, while Kubernetes orchestrates containers across a cluster of machines, handling scheduling, scaling, networking and self-healing.
- Blue-Green DeploymentvsCanary DeploymentBlue-green deployment runs two full environments and switches all traffic from the old one to the new one at once, while canary deployment sends a small share of traffic to the new version first and increases it gradually.
- Reverse ProxyvsLoad BalancerA reverse proxy sits in front of servers and forwards client requests to them, adding features like TLS, caching and security, while a load balancer spreads requests across several servers so no single one is overloaded.
- DevOpsvsSite Reliability EngineeringDevOps is a culture and set of practices that brings development and operations together to ship software faster and more safely, while Site Reliability Engineering is Google's concrete way of running production with software engineering and measurable reliability targets.
- TerraformvsAnsibleTerraform declares and creates cloud infrastructure, such as networks, servers and databases, and tracks it in a state file, while Ansible configures existing machines and deploys software by running tasks over SSH.
- AWSvsAzureAWS is Amazon's cloud, the oldest and largest, with the broadest catalog of services, while Azure is Microsoft's cloud, strongest where companies already use Microsoft products, identity and enterprise agreements.
- Docker ComposevsKubernetesDocker Compose runs a multi-container application on a single machine from one YAML file, while Kubernetes orchestrates containers across a cluster of machines with scheduling, self-healing, scaling and rolling updates.
- IaaSvsPaaSIaaS rents you raw infrastructure, such as virtual machines, storage and networks, which you manage yourself, while PaaS runs your application code for you and manages the servers, operating system and scaling underneath; SaaS sits above both as finished software.
- SLAvsSLOAn SLO is an internal reliability target, such as 99.9% of requests succeeding over 30 days; an SLA is a contract that promises customers a level of service and says what happens, usually credits, when it is missed.
Version Control5 comparisons
- MergevsRebaseGit merge combines two branches by creating a new merge commit that preserves the full history, while git rebase moves your commits on top of another branch, rewriting them to produce a clean, linear history.
- ForkvsBranchA fork is a complete copy of a repository under a different owner, used to contribute to projects you cannot push to directly, while a branch is a separate line of development inside the same repository.
- Git ResetvsGit RevertGit reset moves a branch back to an earlier commit, removing later commits from its history, while git revert adds a new commit that undoes an earlier one's changes, keeping history intact and safe for shared branches.
- GitvsGitHubGit is the version control tool that records the history of your code on your own computer, while GitHub is an online platform that hosts Git repositories and adds collaboration features such as pull requests, issues and CI.
- Git FetchvsGit Pullgit fetch downloads new commits from the remote and updates remote-tracking branches without touching your work, while git pull fetches and then immediately merges or rebases those changes into your current branch.
Security9 comparisons
- AuthenticationvsAuthorizationAuthentication verifies who you are, for example with a password or a passkey, while authorization decides what you are allowed to do once your identity is known, such as reading a file or deleting a user.
- EncryptionvsHashingEncryption scrambles data with a key so it can be decrypted later, while hashing turns data into a fixed-length fingerprint that cannot be reversed, which makes it ideal for checking passwords and file integrity.
- JWTvsSessionA JWT is a signed token that carries the user's identity and claims itself, so servers can verify it without a lookup, while session authentication keeps login state on the server and gives the client only a random session ID.
- XSSvsCSRFXSS (cross-site scripting) injects malicious scripts that run inside a trusted website, while CSRF (cross-site request forgery) tricks a logged-in user's browser into sending unwanted requests to that site from another page.
- SQL InjectionvsXSSSQL injection tricks a server into running database commands written by an attacker, while cross-site scripting (XSS) tricks a website into running an attacker's JavaScript in other users' browsers.
- OAuthvsSSOOAuth is a protocol that lets an app access a user's data on another service without seeing their password, while single sign-on (SSO) is the experience of logging in once to reach many applications, built on protocols such as SAML or OpenID Connect.
- OAuthvsOpenID ConnectOAuth 2.0 is an authorization framework that lets an app access an API on a user's behalf with an access token, while OpenID Connect is an identity layer on top of it that tells the app who the user is with a signed ID token.
- Symmetric EncryptionvsPublic-Key CryptographySymmetric encryption uses one shared secret key to encrypt and decrypt and is very fast, while asymmetric encryption uses a public key to encrypt and a private key to decrypt, which solves key sharing but is much slower.
- JWTvsOAuthOAuth is a framework for giving an app limited access to a user's data without sharing a password; a JWT is a token format. They aren't alternatives: OAuth often issues access tokens that are JWTs.
AI & Machine Learning5 comparisons
- Machine LearningvsDeep LearningMachine learning is the broad field of algorithms that learn patterns from data, while deep learning is a subset that uses many-layered neural networks to learn features automatically, usually needing far more data and computing power.
- RAGvsFine-tuningRAG (retrieval-augmented generation) gives a language model relevant documents at question time so it can answer from fresh, specific sources, while fine-tuning further trains the model on examples to change its built-in behavior or style.
- Supervised LearningvsUnsupervised LearningSupervised learning trains a model on labeled examples so it can predict the right answer for new data, while unsupervised learning finds patterns, groups or structure in data that has no labels at all.
- Artificial IntelligencevsMachine LearningArtificial intelligence is the broad goal of making machines perform tasks that need human intelligence, while machine learning is one way to achieve it, in which systems learn patterns from data instead of following hand-written rules.
- ChatbotvsAI AgentA chatbot holds a conversation and answers questions, while an AI agent works toward a goal on its own, planning steps and using tools such as search, code execution or APIs to take actions.
Software Architecture4 comparisons
- MonolithvsMicroservicesA monolith is one application deployed as a single unit, simple to build and run, while microservices split an application into small, independently deployable services that scale separately but add network and operational complexity.
- MVCvsMVVMMVC splits an application into a model, a view and a controller that handles input and decides what to show, while MVVM puts a ViewModel between model and view and keeps them in sync through data binding.
- MicroservicesvsService-Oriented ArchitectureService-oriented architecture (SOA) splits large enterprise systems into shared services that usually talk through a central enterprise service bus, while microservices split one application into small, independently deployed services that own their data and talk through lightweight APIs.
- Horizontal ScalingvsVertical ScalingHorizontal scaling adds more machines and spreads the load across them, while vertical scaling makes a single machine more powerful with more CPU, memory or faster storage.
Testing & Quality4 comparisons
- Unit TestvsIntegration TestA unit test checks one small piece of code, like a single function, in isolation and runs in milliseconds, while an integration test checks that several parts, such as your code and a database, work correctly together.
- Test-Driven DevelopmentvsBehavior-Driven DevelopmentTest-driven development (TDD) has developers write a failing test before the code that makes it pass, while behavior-driven development (BDD) builds on it by describing expected behavior in plain-language scenarios the whole team can read.
- Black-Box TestingvsWhite-Box TestingBlack-box testing checks software from the outside against its requirements without looking at the code, while white-box testing designs tests from the code's internal structure to exercise its branches and paths.
- CypressvsPlaywrightCypress runs end-to-end tests inside the browser with a friendly interactive runner, while Playwright, from Microsoft, controls browsers from outside and supports multiple tabs, several languages and free parallel runs.
Networking6 comparisons
- TCPvsUDPTCP opens a connection and guarantees that data arrives complete and in order, while UDP sends independent packets with no delivery guarantee, trading reliability for lower latency and overhead.
- LANvsWANA LAN (local area network) connects devices in one building or site over fast links the owner controls, while a WAN (wide area network) connects networks across cities or countries, usually over leased lines or the internet.
- VPNvsProxy ServerA VPN encrypts all network traffic from your device and sends it through a secure tunnel, while a proxy server forwards only the traffic of apps configured to use it and usually adds no encryption of its own.
- IPv4vsIPv6IPv4 uses 32-bit addresses such as 192.168.1.10, allowing about 4.3 billion of them, while IPv6 uses 128-bit addresses such as 2001:db8::1, allowing so many that every device can have its own public address.
- LatencyvsThroughputLatency is how long a single 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 out to the internet on their behalf; a reverse proxy sits in front of servers and receives requests from the internet on theirs.
Data Structures3 comparisons
- StackvsQueueA stack removes the most recently added item first (last in, first out, or LIFO), while a queue removes the oldest item first (first in, first out, or FIFO), like a stack of plates versus a line at a checkout.
- Breadth-First SearchvsDepth-First SearchBreadth-first search (BFS) explores a graph level by level using a queue and finds the shortest path in unweighted graphs, while depth-first search (DFS) follows one branch as deep as possible using a stack before backtracking.
- Merge SortvsQuicksortMerge sort splits a list in half, sorts each half and merges them, guaranteeing O(n log n) time but using extra memory, while quicksort partitions around a pivot in place and is usually faster, but can slow to O(n²) with bad pivots.
Operating Systems5 comparisons
- ProcessvsThreadA process is a running program with its own isolated memory, while a thread is a unit of execution inside a process that shares that memory with the process's other threads, making threads lighter but harder to coordinate safely.
- MutexvsSemaphoreA mutex is a lock that lets exactly one thread at a time use a shared resource and must be released by the thread that took it, while a semaphore is a counter that lets up to N threads in at once and can be released by any thread.
- Stack MemoryvsHeap MemoryThe stack holds each function call's local variables and is managed automatically in last-in, first-out order, which is very fast but small; the heap holds data allocated at runtime with flexible size and lifetime, which is larger but slower to manage.
- CPUvsGPUA CPU has a few powerful cores designed for varied, sequential work full of decisions, while a GPU has thousands of simpler cores designed to perform the same operation on large amounts of data in parallel, such as graphics and AI.
- TerminalvsShellA terminal is the program that displays a text interface and passes your keystrokes on, while the shell is the program running inside it that reads your commands and executes them.
Programming Languages4 comparisons
- GovsRustGo is a simple, garbage-collected language built for quickly developing network services, while Rust guarantees memory safety without a garbage collector through ownership rules, trading a steeper learning curve for more control and speed.
- PythonvsJavaScriptPython is a general-purpose language prized for readable code and its data, AI and automation libraries, while JavaScript is the language of the web, running in every browser and, through Node.js, on servers.
- PythonvsJavaPython is a dynamically typed, concise language popular for data, AI, scripting and web backends, while Java is a statically typed language running on the JVM, widely used for large enterprise systems and Android.
- CvsC++C is a small, procedural systems language from the early 1970s, while C++ grew out of it as a much larger language that adds classes, templates, automatic resource management and a rich standard library.
Teams & Process3 comparisons
- AgilevsWaterfallAgile delivers working software in short, repeated cycles and adapts the plan as feedback arrives, while Waterfall moves through fixed, sequential phases, from requirements and design to building, testing and release.
- ScrumvsKanbanScrum organizes work into fixed-length sprints with set roles and planned goals, while Kanban is a continuous flow system that shows work on a board and limits how many tasks can be in progress at once.
- AgilevsScrumAgile is a set of values and principles for building software in small, frequent steps with constant feedback, while Scrum is one specific framework that puts Agile into practice with fixed roles, sprints and meetings.