Software Engineering & Web Development Core Concepts

A comprehensive collection of vocabulary flashcards covering key software engineering, web development, cloud, and computer science concepts.

Encapsulation

The bundling of data and the methods that operate on that data into a single unit (class), restricting direct access to some components.

Polymorphism

The ability of different classes to be treated as instances of the same class through inheritance, or a single method to have different implementations.

Inheritance

A mechanism where a new class derives properties and behaviors (methods) from an existing parent class.

Data Abstraction

Hiding the complex implementation details of a system and exposing only the essential features to the user.

Single Responsibility Principle ('S' in SOLID)

A class should have one, and only one, reason to change.

Open/Closed Principle ('O' in SOLID)

Software entities should be open for extension but closed for modification.

Liskov Substitution Principle ('L' in SOLID)

Subtypes must be substitutable for their base types without altering program correctness.

Interface Segregation Principle ('I' in SOLID)

Many client-specific interfaces are better than one general-purpose interface.

Dependency Inversion Principle ('D' in SOLID)

Depend upon abstractions, not concretions.

Interface vs. Abstract Class

Interfaces only define method signatures (no implementation) and support multiple inheritance. Abstract classes can have implemented methods and state, but only support single inheritance.

Dependency Injection

A design pattern where an object receives its dependencies from an external source rather than creating them itself, promoting loose coupling.

Singleton Pattern

A creational design pattern that ensures a class has only one instance and provides a global point of access to it.

Pass by Value vs. Pass by Reference

Pass by value passes a copy of the variable. Pass by reference passes the memory address, so changes affect the original variable.

Garbage Collection Roots

Special active objects (like local variables, active threads, and static variables) that the garbage collector uses as a starting point to find reachable objects.

String vs. StringBuilder (C#/Java)

Strings are immutable (cannot be changed after creation). StringBuilder is mutable and more memory-efficient for frequent string concatenations.

Virtual Method (C#)

A method in a base class that can be overridden in a derived class using the 'override' keyword.

Struct vs. Class (C#)

Structs are value types stored on the stack, while classes are reference types stored on the heap.

Exception Handling

A mechanism to handle runtime errors (using try, catch, finally) to maintain normal application flow.

Array

A collection of elements stored in contiguous memory locations, offering $O(1)$ access time by index.

Linked List

A linear data structure where elements are stored in non-contiguous memory, linked together via pointers.

DOM (Document Object Model)

A programming interface that represents an HTML or XML document as a tree of objects.

Event Bubbling (JavaScript)

A mechanism where an event triggered on a deeply nested element propagates upward through its ancestors in the DOM tree.

NaN Property (JavaScript)

'Not-a-Number', representing a value that is not a legal number (e.g., the result of 0/0 or parsing a non-numeric string).

Promise (JavaScript)

An object representing the eventual completion (or failure) of an asynchronous operation and its resulting value.

Primary HTTP Methods

GET, POST, PUT, PATCH, DELETE, OPTIONS, and HEAD.

Idempotent HTTP Method

Making multiple identical requests has the same effect on the server state as making a single request (e.g., GET, PUT, DELETE).

REST (Representational State Transfer)

An architectural style that uses standard HTTP methods and stateless communication for web services.

REST vs. SOAP

REST is an architectural style utilizing standard HTTP and JSON/XML. SOAP is a strict protocol that relies exclusively on XML and requires more bandwidth.

GraphQL

A query language for APIs that allows clients to request exactly the data they need, no more and no less, typically in a single request.

TCP/IP Handshake

A three-way process (SYN, SYN-ACK, ACK) used to establish a reliable connection between a client and a server before data transfer.

DNS (Domain Name System)

The phonebook of the internet, translating human-readable domain names into IP addresses.

TLS/SSL

Cryptographic protocols designed to provide secure, encrypted communication over a computer network.

CORS (Cross-Origin Resource Sharing)

A security feature implemented by browsers to restrict webpages from making requests to a different domain.

HTTP Status Code 200

OK - The request succeeded.

HTTP Status Code 201

Created - The request succeeded and a new resource was created (often used with POST).

HTTP Status Code 400

Bad Request - The server cannot process the request due to a client error (e.g., malformed syntax).

HTTP Status Code 401

Unauthorized - The client must authenticate itself to get the requested response.

HTTP Status Code 403

Forbidden - The client does not have access rights to the content.

HTTP Status Code 500

Internal Server Error - The server encountered a situation it doesn't know how to handle.

Session vs. Cookie Authentication

Sessions store user data on the server and send an ID to the client. Cookies store data directly on the client side.

Amazon RDS

Relational Database Service: A managed distributed relational database service supporting engines like MySQL, PostgreSQL, and MSSQL.

Amazon DynamoDB

A fully managed, highly scalable NoSQL document and key-value database service provided by AWS.

S3 Standard Storage Class

Designed for frequently accessed data, offering high durability, availability, and low latency.

S3 Glacier

A secure, durable, and low-cost S3 storage class specifically designed for data archiving and long-term backup.

AWS Lambda Cold Start

The latency experienced when a serverless function is invoked after being idle, as the cloud provider must allocate resources and initialize the runtime.

Amazon API Gateway

A fully managed service that makes it easy to create, publish, maintain, monitor, and secure APIs at any scale.

AWS VPC

Virtual Private Cloud: A logically isolated section of the AWS cloud where you can launch resources in a virtual network you define.

IAM Role vs. IAM Policy

A Policy is a document defining permissions. A Role is an identity with specific policies attached that can be assumed by users or services.

Elastic Beanstalk vs. EC2

EC2 provides raw virtual servers (IaaS). Elastic Beanstalk is a PaaS that automatically handles deployment, provisioning, load balancing, and scaling.

Infrastructure as Code (IaC)

Managing and provisioning computing infrastructure through machine-readable definition files (like Terraform) rather than physical hardware configuration.

Terraform State Management

Terraform uses a state file (terraform.tfstate) to map real-world resources to your configuration, keep track of metadata, and improve performance for large infrastructures.

Blue/Green Deployment

A release technique that reduces downtime and risk by running two identical production environments; traffic is shifted from the old (Blue) to the new (Green).

Canary Deployment

Rolling out a new software version to a small subset of users before making it available to everyone, to monitor for issues.

Unit Testing

Testing individual components or functions of a software application in isolation to ensure they work as expected.

Integration Testing

Testing the interaction between different modules, services, or systems to ensure they work together correctly.

Continuous Integration (CI)

The practice of automatically integrating code changes from multiple contributors into a single software project frequently, usually triggering automated tests.

Continuous Deployment (CD)

An extension of CI where every change that passes all stages of your production pipeline is released to your customers automatically.

Agile Methodology

An iterative approach to project management and software development that helps teams deliver value faster with fewer headaches through continuous feedback.

Scrum

An Agile framework that helps teams work together, featuring roles (Scrum Master, Product Owner) and time-boxed iterations called Sprints.

SLA (Service Level Agreement)

An external contract between a service provider and a customer outlining expected service levels (like uptime).

SLO (Service Level Objective)

An internal target or goal for a specific metric (e.g., 99.9% uptime) that drives team behavior to meet the SLA.

SLI (Service Level Indicator)

The actual, real-time measurement of a service's performance (e.g., the exact percentage of successful requests).

MTTI (Mean Time To Identify)

The average time it takes an organization to detect a security breach or system failure.

MTTR (Mean Time To Recovery)

The average time it takes to repair a system and restore it to full functionality after an incident.

Database Normalization

The process of organizing data in a database to reduce redundancy and improve data integrity.

First Normal Form (1NF)

A database table structure where all columns contain atomic (indivisible) values and each row is unique.

Second Normal Form (2NF)

A table is in 1NF and all non-key attributes are fully functionally dependent on the entire primary key.

Third Normal Form (3NF)

A table is in 2NF and all non-key attributes are independent of each other (no transitive dependencies).

Primary Key

A specific choice of a minimal set of attributes that uniquely specify a tuple (row) in a database table.

Foreign Key

A field (or collection of fields) in one table that uniquely identifies a row of another table, enforcing referential integrity.

ACID Properties

Atomicity, Consistency, Isolation, Durability: A set of properties that guarantee database transactions are processed reliably.

Atomicity (in ACID)

Ensures that all operations within a work unit are completed successfully; otherwise, the transaction is aborted and rolled back.

CAP Theorem

States that a distributed data store can only guarantee two out of three: Consistency, Availability, and Partition tolerance.

Redis

An open-source, in-memory data structure store used as a database, cache, message broker, and streaming engine.

Inner Join vs. Outer Join

An Inner Join returns only rows with matching values in both tables. An Outer Join returns all rows from one table and matched rows from the other.

N+1 Query Problem

A performance anti-pattern where an application executes one database query to fetch a list of entities, and then N additional queries to fetch related data for each entity.

Database Index

Creates a separate data structure (like a B-Tree) that allows the database to find rows without scanning the entire table to improve read speed.

Database Connection Pooling

A method used to keep database connections open so they can be reused by others, reducing the overhead of establishing new connections.

NoSQL Database Usage

Used when dealing with large volumes of unstructured data, requiring flexible schemas, or needing high horizontal scalability.

Git

A distributed version control system for tracking changes in source code during software development.

Load Balancer

Distributes incoming network traffic across multiple servers to ensure no single server bears too much demand, improving responsiveness and availability.

Round Robin Load Balancing

Distributes client requests sequentially to each server in the pool in a continuous loop.

Least Connections Load Balancing

Directs traffic to the server with the fewest active connections, ideal for environments with varying connection durations.

Microservices Architecture

An architectural style that structures an application as a collection of loosely coupled, independently deployable services.

Monolithic Architecture

A unified software model where the user interface, business logic, and data access components are combined into a single program.

Rate Limiting

A strategy to control the amount of traffic sent to or from a network, preventing API abuse and DoS attacks.

API (Application Programming Interface)

A set of rules and protocols that allows different software applications to communicate with each other.

HashMap Key-Value Behavior

A HashMap can store duplicate values, but it cannot store duplicate keys. If you insert a duplicate key, the old value is overwritten.

HashMap Implementation (Java)

Uses an array of linked lists or trees (buckets). It calculates the hash code of the key to determine the bucket index, then handles collisions within that bucket.

HashMap Collision

Occurs when two different keys generate the same hash code and are mapped to the same bucket index.

HashMap Collision Handling

Typically handled through Chaining (using a linked list/tree at the bucket index) or Open Addressing (finding the next empty slot in the array).

CSS Preprocessors (e.g., Sass)

Pros: Variables, nesting, mixins, and cleaner code. Cons: Requires compilation, adds dependency/complexity to the build process.

LRU Cache

Least Recently Used Cache: A caching strategy that discards the least recently used items first when the cache becomes full.

AWS API Gateway Functions

Acts as a reverse proxy to route requests to appropriate backend services (like Lambda or EC2), handling auth, rate limiting, and analytics.

HTTP vs. HTTPS

HTTPS uses TLS/SSL to encrypt HTTP requests and responses, ensuring secure data transmission.

ORM (Object-Relational Mapping)

A technique that lets you query and manipulate data from a database using an object-oriented paradigm.

Web Service

A standard used for communicating between applications over the web, often implementing REST or SOAP.

Serverless Architecture

A cloud execution model where the cloud provider dynamically manages the allocation and provisioning of servers (e.g., AWS Lambda).

Distributed System

A computing environment in which various components are spread across multiple computers on a network, coordinating via messages.

Latency

The time it takes for a data packet to travel from its source to its destination across a network.