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-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.
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: Faster for simple key-value caching, scales well horizontally.
Redis: Offers more features like persistence, lists, hashes, sets, and pub/sub messaging.
sudo apt update && sudo apt install memcached
sudo systemctl start memcachedIt 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.
✅ 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
You can install Whoops using Composer:
composer require filp/whoopsHere'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.
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.
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.
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.
{{ }})Twig uses double curly braces to output variables:
<p>Hello, {{ name }}!</p>→ If name = "Max", the output will be:
"Hello, Max!"
{% %})Twig supports if-else statements, loops, and other control structures.
{% 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>Twig supports "Base Layouts", similar to Laravel's Blade.
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.
You can include reusable components like a navbar or footer:
{% include 'partials/navbar.html.twig' %}Twig provides many filters to format content:
| Filter | Beispiel | Ausgabe |
|---|---|---|
upper |
`{{ "text" | upper }}` |
lower |
`{{ "TEXT" | lower }}` |
length |
`{{ "Hallo" | length }}` |
date |
`{{ "now" | date("d.m.Y") }}` |
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 }}Model-View-Controller (MVC) is a software architecture pattern that divides an application into three main components:
✔ 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.
MVC is widely used in web and desktop applications, including:
Kirby CMS is a flexible, file-based Content Management System (CMS) designed for developers and designers who value maximum control over their projects. Created by Bastian Allgeier, it is known for its minimalist approach and high adaptability. Here are the key features of Kirby CMS:
Kirby stores content in simple text files (usually Markdown or YAML) instead of relying on a database like MySQL. This makes it ideal for small to medium-sized projects where setting up and maintaining a database is unnecessary.
Kirby doesn’t come with pre-built themes, giving developers complete freedom to create templates and layouts from scratch. It’s PHP-based, allowing you to design dynamic websites tailored to your needs.
The Panel is an intuitive interface for editors to manage content. It provides a clear structure and can be customized to meet the specific requirements of each project, ensuring a user-friendly experience.
Kirby is particularly appealing to web developers because it:
Kirby isn’t free. While you can test it without cost, a license is required for live, production use. This ensures high-quality, ad-free development, making it a popular choice for professional projects.
Kirby is suitable for:
Kirby CMS is perfect for projects that demand maximum flexibility and control. It combines straightforward content management with powerful developer tools, making it a favorite among designers and developers who want to build bespoke websites from scratch.
The LAMP stack is a collection of open-source software used together to develop dynamic websites and web applications. The acronym LAMP stands for the following components:
L – Linux
A – Apache
The LAMP stack is often compared to modern alternatives like the MEAN stack (MongoDB, Express.js, Angular, Node.js), but it remains popular due to its simplicity and reliability, especially for traditional web development projects.
The LEMP stack is a collection of software commonly used together to host dynamic websites and web applications. The acronym "LEMP" represents the individual components of the stack:
Linux: The operating system that serves as the foundation for the stack. It supports the other software components.
Nginx (pronounced "Engine-X"): A high-performance, resource-efficient web server. Nginx is often preferred because it scales better for handling simultaneous connections compared to Apache.
MySQL (or MariaDB): The relational database used to store data. MySQL is commonly paired with PHP to generate dynamic content. Modern setups often use MariaDB, a fork of MySQL.
PHP, Python, or Perl: The scripting language used for server-side programming. PHP is particularly popular in web development for rendering database-driven dynamic content on web pages.
The LEMP stack is a modern alternative to the better-known LAMP stack, which uses Apache as the web server.
SonarQube is an open-source tool for continuous code analysis and quality assurance. It helps developers and teams evaluate code quality, identify vulnerabilities, and promote best practices in software development.
Code Quality Assessment:
Detecting Security Vulnerabilities:
Technical Debt Evaluation:
Multi-Language Support:
Reports and Dashboards:
SonarQube is available in a free Community Edition and commercial editions with advanced features (e.g., for larger teams or specialized security analysis).
PSR-12 is a coding style guideline defined by the PHP-FIG (PHP Framework Interoperability Group). It builds on PSR-1 (Basic Coding Standard) and PSR-2 (Coding Style Guide), extending them to include modern practices and requirements.
PSR-12 aims to establish a consistent and readable code style for PHP projects, facilitating collaboration between developers and maintaining a uniform codebase.
namespace declaration.use statements should follow the namespace declaration.namespace App\Controller;
use App\Service\MyService;
use Psr\Log\LoggerInterface;{ for a class or method must be placed on the next line.public, protected, private) is mandatory for all methods and properties.class MyClass
{
private string $property;
public function myMethod(): void
{
// code
}
}public function myFunction(
int $param1,
string $param2
): string {
return 'example';
}{ must be on the same line as the control structure.if ($condition) {
// code
} elseif ($otherCondition) {
// code
} else {
// code
}[]) for arrays.$array = [
'first' => 'value1',
'second' => 'value2',
];?.public function getValue(?int $id): ?string
{
return $id !== null ? (string) $id : null;
}<?php tag and must not include a closing ?> tag.PSR-12 extends PSR-2 by:
PSR-12 is the standard for modern and consistent PHP code. It improves code quality and simplifies collaboration, especially in team environments. Tools like PHP_CodeSniffer or PHP-CS-Fixer can help ensure adherence to PSR-12 effortlessly.
PSR-11 is a PHP Standard Recommendation (PHP Standard Recommendation) that defines a Container Interface for dependency injection. It establishes a standard way to interact with dependency injection containers in PHP projects.
PSR-11 was introduced to ensure interoperability between different frameworks, libraries, and tools that use dependency injection containers. By adhering to this standard, developers can switch or integrate various containers without modifying their code.
PSR-11 specifies two main interfaces:
ContainerInterface
This is the central interface providing methods to retrieve and check services in the container.
namespace Psr\Container;
interface ContainerInterface {
public function get(string $id);
public function has(string $id): bool;
}get(string $id): Returns the instance (or service) registered in the container under the specified ID.has(string $id): Checks whether the container has a service registered with the given ID.2. NotFoundExceptionInterface
This is thrown when a requested service is not found in the container.
namespace Psr\Container;
interface NotFoundExceptionInterface extends ContainerExceptionInterface {
}3. ContainerExceptionInterface
A base exception for any general errors related to the container.
PSR-11 is widely used in frameworks like Symfony, Laravel, and Zend Framework (now Laminas), which provide dependency injection containers. Libraries like PHP-DI or Pimple also support PSR-11.
Here’s a basic example of using PSR-11:
use Psr\Container\ContainerInterface;
class MyService {
public function __construct(private string $message) {}
public function greet(): string {
return $this->message;
}
}
$container = new SomePSR11CompliantContainer();
$container->set('greeting_service', function() {
return new MyService('Hello, PSR-11!');
});
if ($container->has('greeting_service')) {
$service = $container->get('greeting_service');
echo $service->greet(); // Output: Hello, PSR-11!
}PSR-11 is an essential interface for modern PHP development, as it standardizes dependency management and resolution. It promotes flexibility and maintainability in application development.
React
