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.")

Design by Contract (DbC) is a concept in software development introduced by Bertrand Meyer. It describes a method to ensure the correctness and reliability of software by defining clear "contracts" between different components (e.g., methods, classes).

Core Principles of Design by Contract

In DbC, every software component is treated as a contract party with certain obligations and guarantees:

1. Preconditions
   Conditions that must be true before a method or function can execute correctly.
   → Responsibility of the caller.

2. Postconditions
   Conditions that must be true after the execution of a method or function.
   → Responsibility of the method/function.

3. Invariant (Class Invariant)
   Conditions that must always remain true throughout the lifetime of an object.
   → Responsibility of both the method and the caller.

Goal of Design by Contract

• Clear specification of responsibilities.

• More robust and testable software.

• Errors are detected early (e.g., through contract violations).

Example in Pseudocode

class BankAccount {
    private double balance;

    // Invariant: balance >= 0

    void withdraw(double amount) {
        // Precondition: amount > 0 && amount <= balance
        if (amount <= 0 || amount > balance) throw new IllegalArgumentException();

        balance -= amount;

        // Postcondition: balance has been reduced by amount
    }
}

Benefits

• Clear contracts reduce misunderstandings.

• Easier debugging, as violations are detected immediately.

• Supports defensive programming.

Drawbacks

• Requires extra effort to define contracts.

• Not directly supported by all programming languages (e.g., Java and C++ via assertions, Python with decorators; Eiffel supports DbC natively).

A cron job is a scheduled, recurring background task on Unix- or Linux-based systems. It is managed by the cron daemon, which regularly checks whether a job is due to run according to a predefined schedule.

Key features of a cron job:

• Automation: Automates tasks like backups, updates, email dispatch, or script execution.

• Time control: You define exactly when and how often the job should run (e.g., daily at 3:00 AM or every Monday).

• Configuration: Jobs are scheduled using crontabs (cron tables).

Example syntax (in a crontab file):

0 3 * * * /usr/bin/php /var/www/mein-skript.php

Explanation:

• 0 3 * * * → Runs every day at 3:00 AM

• /usr/bin/php /var/www/my-script.php → The command to execute

Time fields overview:

* * * * *  (Minute Stunde Tag Monat Wochentag)

Benefits:

• Saves time through automation

• Reduces human error

• Ideal for repetitive tasks

A daemon (pronounced like "day-mon", not like the English word "demon") is a background process that runs on a computer system—typically without direct user interaction.

Key characteristics of a daemon:

• Starts automatically during system boot.

• Runs continuously in the background.

• Performs tasks without user input.

• Listens for requests from other programs or network connections.

Examples:

• cron daemon: Executes scheduled tasks (e.g., daily backups).

• sshd: Handles incoming SSH connections.

• httpd or nginx: Web server daemons.

• cupsd: Manages print jobs.

Technical background:

• On Unix/Linux systems, daemon process names often end in "d" (e.g., httpd, systemd).

• Daemons are typically launched at system startup by init systems like systemd or init.

Origin of the term:

The word comes from Greek mythology, where a “daimon” was a guiding spirit or invisible force—aptly describing software that works quietly behind the scenes.

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.

“Link Juice” is a term from Search Engine Optimization (SEO) that refers to the value or authority passed from one webpage to another through hyperlinks. This "juice" helps influence how well a page ranks in search engine results (especially Google).

In simple terms:

When website A links to website B, it passes on some of its credibility or authority — that’s the "link juice." The more trusted and relevant site A is, the more juice it passes.

Key factors that influence link juice:

• Authority of the linking site (e.g., a major news site vs. a small blog)

• Number of outgoing links: The more links on a page, the less juice each one gets.

• Follow vs. Nofollow: Only dofollow links typically pass link juice. Nofollow links (with rel="nofollow") usually don’t.

• Link placement: A link within the main content has more value than one in the footer or sidebar.

• Relevance: A link from a site with related content carries more weight.

Example:

A backlink from Wikipedia to your site gives you a ton of link juice — Google sees it as a sign of trust. A link from an unknown or spammy site, on the other hand, might do little or even harm your rankings.

The Levenshtein distance is a measure of the difference between two strings. It indicates how many single-character operations are needed to transform one string into the other. The allowed operations are:

1. Insertion of a character

2. Deletion of a character

3. Substitution of one character with another

Example:

The Levenshtein distance between "house" and "mouse" is 1, since only one letter (h → m) needs to be changed.

Applications:

Levenshtein distance is used in many areas, such as:

• Spell checking (suggesting similar words)

• DNA sequence comparison

• Plagiarism detection

• Fuzzy searching in databases or search engines

Formula (recursive, simplified):

For two strings a and b of lengths i and j:

lev(a, b) = min(
  lev(a-1, b) + 1,        // deletion
  lev(a, b-1) + 1,        // insertion
  lev(a-1, b-1) + cost    // substitution (cost = 0 if characters are equal; else 1)
)

There are also more efficient dynamic programming algorithms to compute it.

SVG stands for Scalable Vector Graphics. It's an XML-based file format used to describe 2D graphics. SVG allows for the display of vector images that can be scaled to any size without losing quality. It's widely used in web design because it offers high resolution at any size and integrates easily into web pages.

Here are some key features of SVG:

• Vector-based: SVG graphics are made up of lines, curves, and shapes defined mathematically, unlike raster images (like JPEG or PNG), which are made of pixels.

• Scalability: Since SVG is vector-based, it can be resized to any dimension without losing image quality, making it ideal for responsive designs.

• Interactivity and Animation: SVG supports interactivity (e.g., via JavaScript) and animation (e.g., via CSS or SMIL).

• Search engine friendly: SVG content is text-based and can be indexed by search engines, offering SEO benefits.

• Compatibility: SVG files are supported by most modern web browsers and are great for logos, icons, charts, and other graphics.

The "Happy Path" (also known as the "Happy Flow") refers to the ideal scenario in software development or testing where everything works as expected, no errors occur, and all inputs are valid.

Example:

Let’s say you’re developing a user registration form. The Happy Path would look like this:

1. The user enters all required information correctly (e.g., a valid email and secure password).

2. They click “Register.”

3. The system successfully creates an account.

4. The user is redirected to a welcome page.

➡️ No validation errors, no server issues, and no unexpected behavior.

What is the purpose of the Happy Path?

• Initial testing focus: Developers and testers often check the Happy Path first to make sure the core functionality works.

• Basis for use cases: In documentation or requirements, the Happy Path is typically the main scenario before covering edge cases.

• Contrasts with edge cases / error paths: Anything that deviates from the Happy Path (e.g., missing password, server error) is considered an "unhappy path" or "alternate flow."

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)!")
}