Web & Software Development MCQ

Explanation

HTML (HyperText Markup Language) defines the structure and content of web pages using elements (tags). CSS styles them; JavaScript adds interactivity.

Explanation

CSS (Cascading Style Sheets) separates presentation from structure. The "cascading" refers to how multiple style rules are combined by specificity, importance, and source order.

Explanation

The DOM represents HTML as a tree of nodes. JavaScript can manipulate it: document.getElementById(), querySelector(), createElement(), appendChild(). Changes to the DOM update the rendered page.

Explanation

RESTful APIs use HTTP methods: GET (retrieve), POST (create), PUT/PATCH (update), DELETE (remove). Resources are identified by URLs. Responses are typically JSON. Stateless: each request is self-contained.

Explanation

APIs define how applications communicate. Web APIs use HTTP. Libraries expose APIs for using their features. The API contract separates interface from implementation — callers don't need to know internal details.

Explanation

Version control (Git, SVN) tracks every change. Benefits: history, collaboration, branching, rollback, blame/blame. Git is distributed — every clone has the full history.

Explanation

Agile (Scrum, Kanban, XP) iterates in 1-4 week sprints. Key practices: daily standups, sprint planning, retrospectives, continuous delivery. Values responding to change over following a fixed plan.

Explanation

Frontend (React, Vue, Angular): renders UI in the browser. Backend (Node.js, Django, Rails, Spring): handles business logic, database access, authentication. Full-stack developers work on both.

Explanation

Frameworks (Django, React, Spring, Rails) provide the skeleton. Inversion of Control: the framework calls your code, not vice versa. Libraries: you call their code. Frameworks offer conventions reducing boilerplate.

Explanation

Responsive design (Ethan Marcotte 2010): fluid grids (%), flexible images, CSS media queries. Mobile-first approach designs for small screens first then scales up. Alternatives: adaptive design (multiple fixed layouts).

Explanation

OOP: classes define blueprints; objects are instances. Encapsulation hides internal state. Inheritance reuses behavior. Polymorphism allows different implementations of the same interface.

Explanation

Design patterns (GoF: Gang of Four) are categorized as Creational (Singleton, Factory), Structural (Adapter, Decorator), and Behavioral (Observer, Strategy). They communicate proven solutions concisely.

Explanation

TDD: write a failing test (Red) → write minimum code to pass (Green) → refactor cleanly. Ensures tests exist, keeps design simple, and catches regressions. Uncle Bob, Kent Beck advocate TDD.

Explanation

CI: developers merge to mainline frequently, triggering automated builds and tests. CD: automatically deploy passing builds to staging/production. Reduces integration hell and delivery risk. Tools: GitHub Actions, Jenkins, GitLab CI.

Explanation

Docker containers bundle app code + dependencies + OS libraries into an image. "Works on my machine" problem solved: same container runs in dev, CI, and production. Lighter than VMs (shared kernel).

Explanation

Microservices (vs monolith): each service owns its data and can be deployed independently. Enables team autonomy, independent scaling, and technology diversity. Tradeoffs: distributed system complexity, network overhead.

Explanation

GraphQL (Facebook, 2015): client specifies exactly what fields it needs. Single endpoint vs multiple REST endpoints. Supports queries, mutations, and subscriptions. Introspection enables self-documentation.

Explanation

Kubernetes (k8s) manages container clusters: scheduling pods, scaling deployments, load balancing, rolling updates, self-healing. Helm for package management. Used to run microservices at scale.

Explanation

SPAs (React, Vue, Angular) feel like native apps: routing, state management, and rendering in the browser. Tradeoffs: initial load (bundle size), SEO challenges (solved by SSR/SSG), client-side complexity.

Explanation

Parameterized queries: query = "SELECT * FROM users WHERE id = ?" with parameter ID. The DB driver escapes it. Never concatenate user input into SQL strings. ORM frameworks use parameterization by default.

Explanation

Caching layers: browser cache (HTTP headers), CDN cache (edge servers), application cache (Redis, Memcached), database query cache. Cache invalidation ("two hard things in CS") is the key challenge.

Explanation

GET: retrieve, safe (no side effects), idempotent, URL parameters visible in logs/history. POST: create/submit, not idempotent, body carries data. PUT/PATCH: update. DELETE: remove.

Explanation

Authentication: "Are you who you say you are?" — passwords, tokens, biometrics. Authorization: "Are you allowed to access this?" — RBAC, ACLs, JWT claims. Both are required for access control.

Explanation

Webhooks (reverse APIs / push APIs): instead of polling, the service calls your URL. Example: Stripe sends payment events to your webhook URL. You respond with 200 OK to acknowledge receipt.

Explanation

Same-origin policy blocks cross-origin AJAX by default. CORS headers (Access-Control-Allow-Origin) allow the server to whitelist origins. Preflight OPTIONS request checks permissions for non-simple requests.

Explanation

SSR (Next.js, Nuxt): HTML ready for SEO bots, fast FCP. CSR (CRA, Vite): full bundle first, then renders. SSG: pre-render at build time. ISR: regenerate on demand. Modern frameworks blend all approaches.

Explanation

MVC: Model (data, business logic), View (presentation, UI), Controller (handles requests, updates model/view). Used in Rails, Django, Spring MVC, Laravel. Enables separation of concerns and testability.

Explanation

ORMs (Hibernate, SQLAlchemy, ActiveRecord, Eloquent) map tables to classes, rows to objects. Handle CRUD without raw SQL. Tradeoffs: N+1 query problem, less control vs raw SQL for complex queries.

Explanation

JWT: header.payload.signature. Server signs with secret (HS256) or private key (RS256). Client sends JWT in Authorization header. Server verifies signature — no database lookup needed. Risk: can't be invalidated before expiry.

Explanation

package.json: dependencies (runtime), devDependencies (development only), scripts (start, test, build), version, main entry point. package-lock.json (npm) or yarn.lock pins exact versions for reproducible installs.

Explanation

CDNs (Cloudflare, CloudFront, Akamai) cache static assets at edge nodes worldwide. A user in Tokyo gets assets from a Tokyo node rather than a US origin server. Reduces latency from 200ms to <20ms.

Explanation

Webpack (and modern alternatives: Vite, esbuild, Rollup) bundles JS/CSS/images into optimized files. Features: code splitting, tree shaking (dead code elimination), loaders (Babel for transpilation), hot module replacement.

Explanation

SemVer 2.0: 1.2.3 — major.minor.patch. Breaking change → increment major (reset minor/patch). New feature backward-compat → increment minor. Bug fix → increment patch. npm, pip, Cargo all use SemVer.

Explanation

Choose based on access patterns: complex queries/transactions → PostgreSQL, MySQL. Simple key-value lookups/caching → Redis. Document storage with flexible schema → MongoDB. Time-series → InfluxDB. Graph → Neo4j.

Explanation

SSE (EventSource API) is a one-way push from server to client over HTTP. Simpler than WebSockets for read-only streams (live feeds, progress updates). WebSockets are bidirectional. Both enable real-time communication.

Explanation

Web Storage API: localStorage (5-10MB, persistent, shared across tabs from same origin). sessionStorage (5MB, tab-scoped, cleared on tab close). Neither sends data to server (unlike cookies).

Explanation

PWAs use: Service Worker (background processing, offline cache), Web App Manifest (home screen install, splash screen), Push Notifications. Work on any browser/OS without an app store. Starbucks, Twitter Lite are examples.

Explanation

Technical debt: shortcuts taken for speed (hardcoded values, no tests, poor abstractions) accumulate "interest" — future changes take longer. Managing debt requires regular refactoring and code quality practices.

Explanation

CI catches integration bugs early by running tests on every commit. Tools: GitHub Actions, Jenkins, CircleCI, GitLab CI. Key: fast feedback, automated quality gates, a failing build requires immediate attention.

Explanation

SOLID (Robert Martin): S=one reason to change, O=open for extension closed for modification, L=subtypes substitutable for base types, I=small focused interfaces, D=depend on abstractions not concretions.

Explanation

Event-driven: producer emits event (order.placed), broker (Kafka, RabbitMQ) delivers to consumers (payment service, email service). Decoupled, scalable, but harder to debug causality chains.

Explanation

CQRS: writes update the write model, which publishes events; reads use a denormalized read model optimized for queries. Often paired with Event Sourcing. Adds complexity but enables scalability and read optimization.

Explanation

Event sourcing: append events (OrderCreated, OrderShipped) to an event log. Current state = replay of events. Benefits: complete audit trail, temporal queries, easy debugging. Used with CQRS and Kafka.

Explanation

DIP enables loose coupling: UserService depends on IUserRepository (interface), not MySQLUserRepository (concrete). Concrete implementation injected via DI. Enables testing with mocks and swapping implementations.

Explanation

DI: class declares what it needs; a DI container or caller provides it. Enables loose coupling and testability (inject mocks). DI containers (Spring, Dagger, Autofac) manage object graphs automatically.

Explanation

Vertical (scale up): more CPU/RAM — simple but limited. Horizontal (scale out): more servers — requires stateless apps, load balancers, distributed state. Cloud-native apps are designed for horizontal scaling.

Explanation

Idempotency: PUT request applying the same update multiple times has the same effect as once. GET is idempotent. POST usually isn't (creates duplicate records). Essential for retry safety in distributed systems.

Explanation

12-Factor (Heroku): 1) Codebase 2) Dependencies 3) Config 4) Backing services 5) Build/release/run 6) Processes (stateless) 7) Port binding 8) Concurrency 9) Disposability 10) Dev/prod parity 11) Logs 12) Admin processes.

Explanation

Service meshes (Istio, Linkerd, Consul) inject sidecar proxies (Envoy) alongside each service. Capabilities: mutual TLS (mTLS), traffic shaping, distributed tracing, circuit breaking — without application code changes.

Explanation

Eventual consistency (DNS, Amazon DynamoDB): updates propagate asynchronously — reads may see stale data temporarily. Highly available but requires application-level conflict resolution. Strong consistency (ACID, CP systems) sacrifices availability.

Explanation

Circuit breaker (Hystrix, Resilience4j): CLOSED (normal), OPEN (failing — reject calls immediately), HALF-OPEN (test one request). Prevents cascading failures when a dependency is down.

Explanation

Blue-green: switch load balancer from blue (current) to green (new). Instant rollback by switching back. Requires double infrastructure. Alternative: canary deployment (gradually shift traffic %) for lower risk.

Explanation

Strangler Fig (Martin Fowler): create new service for specific features, redirect those requests, keep the monolith for the rest. Over time, more features migrate. Avoids risky big-bang rewrites.

Explanation

IaC (Terraform, Pulumi, Ansible, CloudFormation): version-control infrastructure, peer-review changes, reproducible environments. Prevents configuration drift and enables disaster recovery.

Explanation

Observer pattern (publish-subscribe): EventEmitter in Node.js, addEventListener in DOM, @Output in Angular. The subject doesn't know who its observers are — loose coupling. Foundation for reactive programming.

Explanation

Monorepo (Google, Meta, Microsoft, Nx, Turborepo): atomic cross-project changes, shared tooling, unified testing. Polyrepo: team autonomy, independent versioning. No universal winner; depends on team size and coupling needs.

Explanation

Hydration: server renders HTML (fast visible content), client downloads JS bundle, React/Vue hydrates existing DOM (attaches event handlers). Partial hydration (Islands Architecture) hydrates only interactive components.

Explanation

AP systems (most web services): remain available with eventual consistency during partitions. CP systems (financial: bank balances): refuse service rather than return stale data. Choice drives architecture decisions.

Explanation

Saga: each step is a local DB transaction + event. On failure, compensating transactions undo previous steps. Choreography: services react to events. Orchestration: a central coordinator directs. Used in e-commerce orders.

Explanation

PKCE: client generates random code_verifier, sends SHA256 hash (code_challenge) in auth request. After redirect, sends code_verifier with token request — proves the token requester is the auth initiator.

Explanation

gRPC (Google): IDL defines services, Protobuf serializes efficiently (5-10x smaller than JSON), HTTP/2 enables multiplexing and streaming. Ideal for internal microservices. REST: better browser support, human-readable.

Explanation

Load balancers (Nginx, HAProxy, AWS ELB) use selection algorithms like round-robin, least connections, weighted distribution, or IP hashing for session affinity, and continuously run health checks so traffic is not routed to failing instances.

Explanation

Opening a new TCP connection and authenticating with the database for every request is expensive. Connection pools (PgBouncer, HikariCP, Laravel's persistent connections) keep a set of warm connections that requests borrow and return, reducing latency and preventing resource exhaustion under load.

Explanation

Mocks and stubs stand in for slow or unpredictable collaborators (a payment gateway, a database) so a unit test can verify behavior in isolation, run quickly, and produce the same result every time it runs.

Explanation

Merge records a new commit joining two histories, keeping an accurate (if branchy) record of what happened. Rebase replays your commits onto the tip of main, yielding a cleaner linear history but rewriting commit hashes — risky on shared branches.

Explanation

A repository (e.g., OrderRepository) exposes methods like find() and save() while hiding whether data comes from MySQL, MongoDB, or an API. Swapping the underlying store or substituting a fake for tests does not require touching business logic.

Explanation

Pagination (offset-based with page/limit, or cursor-based for large/changing datasets) lets an API return manageable chunks of data, which keeps response payloads small, reduces server load, and improves perceived performance for the client.

Explanation

A race condition occurs when two or more operations read and write shared data concurrently and the final result depends on execution order — for example, two requests incrementing a counter at the same time and one update being lost. Locks, atomic operations, and transactions prevent it.

Explanation

Trunk-based development keeps everyone merging small changes into a shared main branch frequently. Feature flags let half-finished work ship to production hidden behind a toggle, avoiding the integration pain of long-lived feature branches.

Explanation

Rate limiting (token bucket, sliding window, fixed window algorithms) restricts request volume per client/IP/API key over time. It protects backend resources from being overwhelmed and keeps the service fair and available for all consumers.

Explanation

Unit tests isolate a single piece of logic (often using mocks for collaborators) and run very fast. Integration tests exercise the interaction between real components — application code with a real database, message queue, or third-party API — catching issues unit tests miss.

Explanation

A database index is a data structure (commonly a B-tree) that lets the engine locate rows quickly without scanning every row. The cost is extra disk space and slower writes, since every indexed column must be kept in sync whenever a row changes.

Explanation

Staging closely mirrors production (same infrastructure, similar data volume, same configuration patterns) so a team can catch deployment, integration, and configuration issues before they affect real users — a step beyond local development and automated CI test runs.

Explanation

DRY encourages factoring out duplicated logic into a single, well-named place so changes happen in one spot. Taken too far, it can produce a tangled abstraction shared by unrelated use cases — sometimes a little duplication is easier to evolve than a forced abstraction (the "wrong abstraction" problem).

Explanation

OpenAPI describes an API in a structured, machine-readable YAML/JSON document. Tooling can then generate interactive documentation (Swagger UI), client libraries in multiple languages, mock servers for early frontend development, and contract tests that verify the implementation matches the spec.

Explanation

The strategy pattern lets you define several interchangeable behaviors (e.g., different sorting or pricing algorithms) behind a common interface, and choose or swap the concrete implementation at runtime — avoiding large conditional blocks and making new behaviors easy to add.

Explanation

Code coverage tools (Istanbul, JaCoCo, PHPUnit coverage) report what percentage of code paths ran during tests. A high number means code was executed, but tests without meaningful assertions can still show 100% coverage while verifying nothing — coverage is a useful signal, not a quality guarantee.

Explanation

Migrations (Laravel, Rails ActiveRecord, Django, Flyway) are ordered, version-controlled files describing schema changes — creating tables, adding columns, etc. Running them in sequence keeps every environment's schema consistent and lets teams track and roll back changes like any other code.

Explanation

Code review (pull requests on GitHub/GitLab) catches bugs and design issues early, spreads knowledge of the codebase across the team, enforces consistent style and standards, and serves as a teaching opportunity for both reviewer and author — well beyond simply finding faults.

Explanation

Loose coupling means components depend on stable contracts (interfaces, APIs, message formats) rather than each other's internals. This makes systems easier to change, test independently, deploy separately, and replace piece by piece without a cascade of breakages.

Explanation

ES+CQRS: append-only event store, project events to multiple read models optimized for different queries. Challenges: event schema evolution, eventual consistency lag, projection rebuilds, operational complexity.

Explanation

CSP: Content-Security-Policy: default-src 'self'; script-src cdn.example.com. Blocks inline scripts (unsafe-inline) and eval(). Nonces/hashes allow specific inline scripts. Makes XSS exploitation much harder even if code is injected.

Explanation

Compile-time (early binding): C++ templates, Java generics, function overloading. Runtime (late binding): virtual method calls through vtables/dispatch tables. Java interfaces, C++ virtual enable runtime polymorphism.

Explanation

HTTP/3 (RFC 9114) over QUIC (RFC 9000): per-stream loss recovery (no HoL blocking), connection migration (IP change without reconnecting), 0-RTT resumption. Adopted by Cloudflare, Google, Meta.

Explanation

Reactive Manifesto (2013): responsive under load, resilient under failure (replication, isolation), elastic (scales up/down), message-driven (location transparency, back-pressure). Implemented by Akka, RxJava, Project Reactor.

Explanation

TLS handshake: ECDHE generates a shared secret using asymmetric math. From this shared secret, HKDF derives symmetric session keys for AES-GCM bulk encryption. Asymmetric crypto is 100-1000x slower than symmetric.

Explanation

In a service with 10 dependencies, P99 of the slowest is ~1-(0.99^10) ≈ 10% slow requests at the edge. "The Long Tail of Latency" (Google): optimize P99, not just average. Techniques: timeouts, hedged requests, tail-cutting.

Explanation

Bounded contexts map to teams and services. Context mapping: shared kernel, customer-supplier, anticorruption layer. Ubiquitous language is consistent within a context. Prevents semantic confusion across large domains.

Explanation

WASM enables compute-intensive code (image editing, 3D rendering, video encoding, games) in browsers at near-native speed. AutoCAD, Figma, Google Earth use WASM. WASI extends it to server-side.

Explanation

Orchestration saga (Temporal, AWS Step Functions): workflow coordinator calls services and handles failures. Choreography saga (Kafka events): each service does its work and emits events; others react. Choose based on complexity and coupling requirements.

Explanation

Sync: service A waits for service B's response — if B is down, A fails. Async: A publishes to Kafka, B consumes when ready — temporal decoupling. Choose async for resilience; sync for simplicity when coupling is acceptable.

Explanation

Feature flags (LaunchDarkly, Split, Unleash): deploy code dark (disabled), enable for % of users, monitor, roll back by toggle — not by reverting code. Enables trunk-based development and continuous deployment safely.

Explanation

API gateways (Kong, AWS API Gateway, Nginx): off-load auth, rate limiting, TLS termination from services. Backend-For-Frontend (BFF) pattern: specialized gateways per client type (mobile, web, partner APIs) with different data shapes.

Explanation

Chaos engineering (Netflix Chaos Monkey, Gremlin): deliberately kill servers, inject network latency, corrupt data. Principles: build hypotheses about steady-state, inject chaos, observe, improve. GameDays test incident response.

Explanation

Stateless (ideal): any instance handles any request. Scale horizontally, restart freely. Stateful: session/cart data must go to the same instance or external state store (Redis). 12-factor mandates stateless processes.

Explanation

Observability (CNCF): Metrics (Prometheus/Grafana: counters, gauges, histograms), Logs (structured: JSON, correlated with trace IDs), Distributed Tracing (Jaeger, Zipkin: end-to-end request flows). OpenTelemetry standardizes collection.

Explanation

Compensating transactions undo the business effect of a step. Challenges: some effects are irreversible (sending email, SMS, physically dispatching goods). Design sagas with reversibility in mind; for irreversible steps, use careful sequencing.

Explanation

12-Factor Factor III: config in env. Different environments (dev, staging, prod) have different values for database URLs, API keys, feature flags. Env vars are external to code, never committed, and work across languages and OSes.

Explanation

When a hot cache entry expires, every concurrent request can simultaneously fall through to the origin (database or backend service), causing a spike that can crash it. Adding random jitter to expiration times, coalescing duplicate in-flight requests, or locking so only one request recomputes the value are standard mitigations.

Explanation

Without backpressure, a fast producer can flood a slower consumer, causing unbounded queues, memory exhaustion, or dropped messages. Reactive Streams, RxJava, and message brokers implement backpressure so consumers can request data at a sustainable rate, keeping the whole pipeline stable under load.