Shopware is a modular e-commerce system from Germany that allows you to create and manage online stores. It’s designed for both small retailers and large enterprises, known for its flexibility, scalability, and modern technology.

🔹 General Information:

• Developer: Shopware AG (founded in 2000 in Germany)

• Technology: PHP, Symfony framework, API-first approach

• Current Version: Shopware 6 (since 2019)

• Open Source: Yes, with paid extensions available

• Headless Ready: Yes, supports headless commerce via APIs

🔹 Key Features:

• Product Management: Variants, tier pricing, media, SEO tools

• Sales Channels: Web shop, POS, social media, marketplaces

• Content Management: Built-in CMS ("Shopping Experiences")

• Payments & Shipping: Many integrations (e.g. PayPal, Klarna)

• Multilingual & Multi-Currency Support

• B2B & B2C capabilities

• App System & API for custom extensions

🔹 Who is Shopware for?

• Startups (free Community Edition available)

• SMEs and mid-sized businesses

• Enterprise clients with complex needs

• Very popular in the DACH region (Germany, Austria, Switzerland)

🔹 Advantages:

• Made in Germany → GDPR-compliant

• Highly customizable

• Active ecosystem & community

• Scalable for growing businesses

A Prepared Statement is a programming technique, especially used when working with databases, to make SQL queries more secure and efficient.

1. How does a Prepared Statement work?

It consists of two steps:

1. Prepare the SQL query with placeholders
   Example in SQL:

SELECT * FROM users WHERE username = ? AND password = ?

• (Some languages use :username or other types of placeholders.)

• Bind parameters and execute
  The real values are bound later, for example:

$stmt->bind_param("ss", $username, $password);
$stmt->execute();

2. Advantages

✅ Protection against SQL injection:
User input is treated separately and safely, not directly inserted into the SQL string.

✅ Faster with repeated use:
The SQL query is parsed once by the database server and can be executed multiple times efficiently (e.g., in loops).

3. Example in PHP using MySQLi

$conn = new mysqli("localhost", "user", "pass", "database");
$stmt = $conn->prepare("SELECT * FROM users WHERE email = ?");
$stmt->bind_param("s", $email); // "s" stands for string
$email = "example@example.com";
$stmt->execute();
$result = $stmt->get_result();

In short:

A Prepared Statement separates SQL logic from user input, making it a secure (SQL Injection) and recommended practice when dealing with databases.

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.

💡 What is an Entity Manager?

An Entity Manager is a core component of ORM (Object-Relational Mapping) frameworks, especially in Java (JPA – Java Persistence API), but also in other languages like PHP (Doctrine ORM).

📦 Responsibilities of an Entity Manager:

1. Persisting:

   • Saves a new object (entity) to the database.

   • Example (Doctrine): $entityManager->persist($user);

2. Finding/Loading:

   • Retrieves an object by its ID or other criteria.

   • Example: $entityManager->find(User::class, 1);

3. Updating:

   • Tracks changes to objects and writes them to the database (usually via flush()).

4. Removing:

   • Deletes an object from the database.

   • Example: $entityManager->remove($user);

5. Managing Transactions:

   • Begins, commits, or rolls back transactions.

6. Handling Queries:

   • Executes custom queries, often using DQL (Doctrine Query Language) or JPQL.

🔁 Entity Lifecycle:

The Entity Manager tracks the state of entities:

• managed (being tracked),

• detached (no longer tracked),

• removed (marked for deletion),

• new (not yet persisted).

🛠 Example with Doctrine (PHP):

$user = new User();
$user->setName('Max Mustermann');

$entityManager->persist($user); // Mark for saving
$entityManager->flush();        // Write to DB

✅ Summary:

The Entity Manager is the central component for working with database objects — creating, reading, updating, deleting. It abstracts SQL and provides a clean, object-oriented way to interact with your data layer.

Doctrine DBAL (Database Abstraction Layer) is a PHP library that provides an abstraction layer for database access. It is part of the Doctrine project (a popular ORM for PHP), but it can be used independently of the ORM.

Purpose and Benefits of Doctrine DBAL:

Doctrine DBAL offers a unified API to interact with different databases (such as MySQL, PostgreSQL, SQLite, etc.) without writing raw SQL specific to each database system.

Key Features of Doctrine DBAL:

• Connection Management

• • Easily configure and manage connections to various database systems.

  • Supports connection pooling, transactions, and more.

• SQL Query Builder

• • Build SQL queries programmatically using an object-oriented API:

$qb = $conn->createQueryBuilder();
$qb->select('u.id', 'u.name')
   ->from('users', 'u')
   ->where('u.age > :age')
   ->setParameter('age', 18);
$stmt = $qb->executeQuery();

• Database Independence

  • The same code works with different database systems (e.g., MySQL, PostgreSQL) with minimal changes.

• Schema Management

  • Tools to create, update, and compare database schemas.

  • Useful for migrations and automation.

• Data Type Conversion

  • Automatically converts data between PHP types and database-native types.

use Doctrine\DBAL\DriverManager;

$conn = DriverManager::getConnection([
    'dbname' => 'test',
    'user' => 'root',
    'password' => '',
    'host' => 'localhost',
    'driver' => 'pdo_mysql',
]);

$result = $conn->fetchAllAssociative('SELECT * FROM users');

When to Use DBAL Instead of ORM:

You might choose DBAL without ORM if:

• You want full control over your SQL.

• Your project doesn't need complex object-relational mapping.

• You're working with a legacy database or custom queries.

Summary:

Doctrine DBAL is a powerful tool for clean, portable, and secure database access in PHP. It sits between raw PDO usage and a full-featured ORM like Doctrine ORM, making it ideal for developers who want abstraction and flexibility without the overhead of ORM logic.

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.

Memcached is a distributed in-memory caching system commonly used to speed up web applications. It temporarily stores frequently requested data in RAM to avoid expensive database queries or API calls.

Key Features of Memcached:

• Key-Value Store: Data is stored as key-value pairs.

• In-Memory: Runs entirely in RAM, making it extremely fast.

• Distributed: Supports multiple servers (clusters) to distribute load.

• Simple API: Provides basic operations like set, get, and delete.

• Eviction Policy: Uses LRU (Least Recently Used) to remove old data when memory is full.

Common Use Cases:

• Caching Database Queries: Reduces load on databases like MySQL or PostgreSQL.

• Session Management: Stores user sessions in scalable web applications.

• Temporary Data Storage: Useful for API rate limiting or short-lived data caching.

Memcached vs. Redis:

• Memcached: Faster for simple key-value caching, scales well horizontally.

• Redis: Offers more features like persistence, lists, hashes, sets, and pub/sub messaging.

Installation & Usage (Example for Linux):

sudo apt update && sudo apt install memcached
sudo systemctl start memcached

It can be used with PHP or Python via appropriate libraries.

The Whoops PHP library is a powerful and user-friendly error handling tool for PHP applications. It provides clear and well-structured error pages, making it easier to debug and fix issues.

Key Features of Whoops

✅ Beautiful, interactive error pages
✅ Detailed stack traces with code previews
✅ Easy integration into existing PHP projects
✅ Support for various frameworks (Laravel, Symfony, Slim, etc.)
✅ Customizable with custom handlers and loggers

Installation

You can install Whoops using Composer:

composer require filp/whoops

Basic Usage

Here's a simple example of how to enable Whoops in your PHP project:

require 'vendor/autoload.php';

use Whoops\Run;
use Whoops\Handler\PrettyPageHandler;

$whoops = new Run();
$whoops->pushHandler(new PrettyPageHandler());
$whoops->register();

// Trigger an error (e.g., calling an undefined variable)
echo $undefinedVariable;

If an error occurs, Whoops will display a clear and visually appealing debug page.

Customization & Extensions

You can extend Whoops by adding custom error handling, for example:

use Whoops\Handler\CallbackHandler;

$whoops->pushHandler(new CallbackHandler(function ($exception, $inspector, $run) {
    error_log($exception->getMessage());
}));

This version logs errors to a file instead of displaying them.

Use Cases

Whoops is mainly used in development environments to quickly detect and fix errors. However, in production environments, it should be disabled or replaced with a custom error page.

What is Twig?

Twig is a powerful and flexible templating engine for PHP, commonly used in Symfony but also in other PHP projects. It helps separate logic from presentation and offers many useful features for frontend development.

Key Features of Twig

1. Simple Syntax with Placeholders ({{ }})

Twig uses double curly braces to output variables:

<p>Hello, {{ name }}!</p>

→ If name = "Max", the output will be:
"Hello, Max!"

2. Control Structures ({% %})

Twig supports if-else statements, loops, and other control structures.

If-Else

{% if user.isAdmin %}
    <p>Welcome, Admin!</p>
{% else %}
    <p>Welcome, User!</p>
{% endif %}

Loops (for)

<ul>
{% for user in users %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

3. Template Inheritance

Twig supports "Base Layouts", similar to Laravel's Blade.

Parent Template (base.html.twig)

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}My Page{% endblock %}</title>
</head>
<body>
    <header>{% block header %}Default Header{% endblock %}</header>
    <main>{% block content %}{% endblock %}</main>
</body>
</html>

Child Template (page.html.twig)

{% extends 'base.html.twig' %}

{% block title %}Homepage{% endblock %}

{% block content %}
    <p>Welcome to my website!</p>
{% endblock %}

→ The blocks override the default content from the base template.

4. Including Templates

You can include reusable components like a navbar or footer:

{% include 'partials/navbar.html.twig' %}

5. Filters & Functions

Twig provides many filters to format content:

6. Security & Escaping

Twig automatically escapes HTML to prevent XSS attacks:

{{ "<script>alert('XSS');</script>" }}

→ Outputs: <script>alert('XSS');</script>

To output raw HTML, use |raw:

{{ "<strong>Bold</strong>"|raw }}

7. Extensibility

• Twig supports custom filters & functions.
• You can use PHP objects and arrays directly inside Twig.

Model-View-Controller (MVC) is a software architecture pattern that divides an application into three main components:

1. Model (Data & Logic)

• Manages data and business logic.
• Contains rules for data processing.
• Independent of the user interface.

2. View (User Interface)

• Displays data from the model to the user.
• Ensures data is presented in an understandable format.
• Responds to user actions by forwarding requests to the controller.

3. Controller (Control & Interaction)

• Acts as an intermediary between the model and the view.
• Handles user inputs, processes them, and updates the model or view accordingly.
• Does not contain business logic or data manipulation itself.

How Does MVC Work in Practice?

1. The user interacts with the view (e.g., clicks a button).
2. The controller processes the input and sends a request to the model.
3. The model executes the required logic (e.g., database queries) and returns the result.
4. The view updates to display the new data.

Example: Blog System

• Model: Stores blog posts in the database.
• View: Displays blog posts in HTML.
• Controller: Handles user input, such as submitting a new blog post, and passes it to the model.

Advantages of MVC

✔ Better maintainability through a clear separation of concerns.
✔ Reusability of components.
✔ Easy testability since logic is separated from the interface.
✔ Flexibility, as different views can be used for the same model.

Use Cases

MVC is widely used in web and desktop applications, including:

• Web frameworks: Laravel (PHP), Django (Python), ASP.NET (C#)
• Frontend frameworks: Angular, React (often with Flux or Redux)
• Desktop applications: JavaFX, SwiftUI, .NET applications