PDO stands for PHP Data Objects and it's a database abstraction layer in PHP. It provides an object-oriented interface to access different types of databases—such as MySQL, PostgreSQL, or SQLite—without needing to change much of your code.

Key Features of PDO:

✅ Consistent API
Same code style regardless of which database you use.

✅ Prepared Statements
Helps prevent SQL injection via bound parameters:

$stmt = $pdo->prepare("SELECT * FROM users WHERE id = :id");
$stmt->execute(['id' => $userId]);

✅ Transactions Support
Great for use cases like banking systems or other operations that need rollback/commit.

✅ Exception-based Error Handling

$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

✅ Easy Database Switching
Switching from MySQL to PostgreSQL? Usually only the DSN and driver need to be changed.

Example: Connecting to MySQL with PDO

$dsn = 'mysql:host=localhost;dbname=testdb;charset=utf8mb4';
$user = 'root';
$pass = '';

try {
    $pdo = new PDO($dsn, $user, $pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Connected successfully!";
} catch (PDOException $e) {
    echo "Connection failed: " . $e->getMessage();
}

Summary:

PDO is the recommended way to work with databases in modern PHP applications—especially for its security, flexibility, and ease of use.

A Join Point is a concept from Aspect-Oriented Programming (AOP).

Definition:

A Join Point is a specific point during the execution of program code where additional behavior (called an aspect) can be inserted.

Typical examples of Join Points:

• Method calls

• Method executions

• Field access (read/write)

• Exception handling

Context:

In AOP, cross-cutting concerns (like logging, security, or transaction management) are separated from the main business logic. These concerns are applied at defined points in the program flow — the Join Points.

Related terms:

• Pointcut: A way to specify which Join Points should be affected (e.g., "all methods starting with save").

• Advice: The actual code that runs at a Join Point (e.g., "log this method call").

• Aspect: A combination of Pointcut(s) and Advice(s) — the full module that implements a cross-cutting concern.

Example (in Spring AOP):

@Before("execution(* com.example.service.*.*(..))")
public void logBeforeMethod(JoinPoint joinPoint) {
    System.out.println("Calling method: " + joinPoint.getSignature().getName());
}

→ This logs a message before every method call in a specific package. The joinPoint.getSignature() call provides details about the actual Join Point.

Aspect-Oriented Programming (AOP) is a programming paradigm focused on modularizing cross-cutting concerns—aspects of a program that affect multiple parts of the codebase and don't fit neatly into object-oriented or functional structures.

💡 Goal:

Typical cross-cutting concerns include logging, security checks, error handling, transaction management, or performance monitoring. These concerns often appear in many classes and methods. AOP allows you to write such logic once and have it automatically applied where needed.

🔧 Key Concepts:

• Aspect: A module that encapsulates a cross-cutting concern.

• Advice: The actual code to be executed (e.g., before, after, or around a method call).

• Join Point: A point in the program flow where an aspect can be applied (e.g., method execution).

• Pointcut: A rule that defines which join points are affected (e.g., "all methods in class X").

• Weaving: The process of combining aspects with the main program code—at compile-time, load-time, or runtime.

🛠 Example (Java with Spring AOP):

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBeforeMethod(JoinPoint joinPoint) {
        System.out.println("Calling method: " + joinPoint.getSignature().getName());
    }
}

This code automatically logs a message before any method in the com.example.service package is executed.

✅ Benefits:

• Improved modularity

• Reduced code duplication

• Clear separation of business logic and system-level concerns

❌ Drawbacks:

• Can reduce readability (the flow isn't always obvious)

• Debugging can become more complex

• Often depends on specific frameworks (e.g., Spring, AspectJ)

Assertions are programming constructs used to check assumptions about the state of a program. An assertion tests whether a specific condition is true—if it isn't, an error is typically raised and the program stops.

x = 10
assert x > 0   # passes
assert x < 5   # raises AssertionError, since x is not less than 5

Purpose of Assertions:

• They help with debugging: you can verify that certain conditions in code hold true during development.

• They document implicit assumptions, e.g., “At this point, the list must have at least one item.”

• They are mainly used during development—assertions are often disabled in production code.

Key Difference from Regular Error Handling:

Assertions are meant to catch programmer errors, not user input or external failures. For example:

• assert age > 0 → inappropriate if age comes from user input.

• Instead, use: if age <= 0: raise ValueError("Age must be positive.")

Perl Compatible Regular Expressions (PCRE) are a type of regular expression syntax and engine that follows the powerful and flexible style of the Perl programming language. They offer advanced features that go beyond the basic regular expressions found in many older systems.

Why "Perl Compatible"?

Perl was one of the first languages to introduce highly expressive regular expressions. The PCRE library was created to bring those capabilities to other programming languages and tools, including:

• PHP

• Python (similar via the re module)

• JavaScript (with slight differences)

• pcregrep (a grep version supporting PCRE)

• Editors like VS Code, Sublime Text, etc.

Key Features of PCRE:

✅ Lookahead & Lookbehind:

• (?=...) – positive lookahead

• (?!...) – negative lookahead

• (?<=...) – positive lookbehind

• (?<!...) – negative lookbehind

✅ Non-greedy quantifiers:

• *?, +?, ??, {m,n}?

✅ Named capturing groups:

• (?P<name>...) or (?<name>...)

✅ Unicode support:

• \p{L} matches any kind of letter in any language

✅ Assertions and anchors:

• \b, \B, \A, \Z, \z

✅ Inline modifiers:

• (?i) for case-insensitive

• (?m) for multiline matching, etc.

(?<=\buser\s)\w+

This expression matches any word that follows "user " using a lookbehind assertion.

Summary:

PCRE are like the "advanced edition" of regular expressions — highly powerful, widely used, and very flexible. If you're working in an environment that supports PCRE, you can take advantage of rich pattern matching features inspired by Perl.

In software development, a guard (also known as a guard clause or guard statement) is a protective condition used at the beginning of a function or method to ensure that certain criteria are met before continuing execution.

In simple terms:

A guard is like a bouncer at a club—it only lets valid input or states through and exits early if something is off.

Typical example (in Python):

def divide(a, b):
    if b == 0:
        return "Division by zero is not allowed"  # Guard clause
    return a / b

This guard prevents the function from attempting to divide by zero.

Benefits of guard clauses:

• Early exit on invalid conditions

• Improved readability by avoiding deeply nested if-else structures

• Cleaner code flow, as the "happy path" (normal execution) isn’t cluttered by edge cases

Examples in other languages:

JavaScript:

function login(user) {
  if (!user) return; // Guard clause
  // Continue with login logic
}

Swift (even has a dedicated guard keyword):

func greet(person: String?) {
  guard let name = person else {
    print("No name provided")
    return
  }
  print("Hello, \(name)!")
}

An implicit join is a way of joining tables in SQL without using the JOIN keyword explicitly. Instead, the join is expressed using the WHERE clause.

Example of an implicit join:

SELECT *
FROM customers, orders
WHERE customers.customer_id = orders.customer_id;

In this example, the tables customers and orders are joined using a condition in the WHERE clause.

In contrast, an explicit join looks like this:

SELECT *
FROM customers
JOIN orders ON customers.customer_id = orders.customer_id;

Differences:

When is an implicit join used?

It was common in older SQL code, but explicit joins are recommended today, as they are clearer, easier to maintain, and less error-prone, especially in complex queries involving multiple tables.

An Early Exit is a programming technique where a function or algorithm terminates early when a specific condition is met. The goal is usually to make the code more efficient and easier to read.

Example in a function:

function getDiscount($age) {
    if ($age < 18) {
        return 10; // 10% discount for minors
    }
    if ($age > 65) {
        return 15; // 15% discount for seniors
    }
    return 0; // No discount for other age groups
}

Here, the Early Exit ensures that the function immediately returns a value as soon as a condition is met. This avoids unnecessary else blocks and makes the code more readable.

Comparison with a nested version:

function getDiscount($age) {
    $discount = 0;
    if ($age < 18) {
        $discount = 10;
    } else {
        if ($age > 65) {
            $discount = 15;
        }
    }
    return $discount;
}

This version introduces unnecessary nesting, reducing readability.

Other Use Cases:

• Input validation at the start of a function (return or throw for invalid input)

• Breaking out of loops early when the desired result is found (break or return)

An Early Exit improves readability, maintainability, and performance in code.

Vite is a modern build tool and development server for web applications, created by Evan You, the creator of Vue.js. It is designed to make the development and build processes faster and more efficient. The name "Vite" comes from the French word for "fast," reflecting the primary goal of the tool: a lightning-fast development environment.

The main features of Vite are:

1. Fast Development Server: Vite uses modern ES modules (ESM), providing an ultra-fast development server. It only loads the latest module, making the initial startup much faster than traditional bundlers.

2. Hot Module Replacement (HMR): HMR works extremely fast by updating only the changed modules, without needing to reload the entire application.

3. Modern Build System: Vite uses Rollup under the hood to bundle the final production build, enabling optimized and efficient builds.

4. Zero Configuration: Vite is very user-friendly and doesn’t require extensive configuration. It works immediately with the default settings, supporting many common web technologies out-of-the-box (e.g., Vue.js, React, TypeScript, CSS preprocessors, etc.).

5. Optimized Production: For production builds, Rollup is used, which is known for creating efficient and optimized bundles.

Vite is mainly aimed at modern web applications and is particularly popular with developers working with frameworks like Vue, React, or Svelte.

A spider (also called a web crawler or bot) is an automated program that browses the internet to index web pages. These programs are often used by search engines like Google, Bing, or Yahoo to discover and update content in their search index.

How a Spider Works:

1. Starting Point: The spider begins with a list of URLs to crawl.

2. Analysis: It fetches the HTML code of a webpage and analyzes its content, links, and metadata.

3. Following Links: It follows the links found on the page to discover new pages.

4. Storage: The collected data is sent to the search engine’s database for indexing.

5. Repetition: The process is repeated regularly to keep the index up to date.

Uses of Spiders:

• Search engine optimization (SEO)

• Price comparison websites

• Web archiving (e.g., Wayback Machine)

• Automated content analysis for AI models

Some websites use a robots.txt file to specify which areas can or cannot be crawled by a spider.