bg_image
header

Twig

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:

Filter Beispiel Ausgabe
upper `{{ "text" upper }}`
lower `{{ "TEXT" lower }}`
length `{{ "Hallo" length }}`
date `{{ "now" date("d.m.Y") }}`

6. Security & Escaping

Twig automatically escapes HTML to prevent XSS attacks:

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

→ Outputs: &lt;script&gt;alert('XSS');&lt;/script&gt;

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.

View

The View in Model-View-Controller (MVC)

The View is the presentation layer in the MVC architecture. It is responsible for displaying data from the Model in a user-friendly format.


Main Responsibilities of the View

Displaying Data: Shows information from the Model (e.g., a list of blog posts).
Reacting to User Interactions: Accepts user input and sends it to the Controller.
Formatting & Layout: Structures content using HTML, CSS, or templating engines (e.g., Laravel Blade or Twig).
Avoiding Business Logic: Contains only presentation logic, not data processing.


How Does the View Work in MVC?

  1. The user sends a request (e.g., "Show all blog posts").
  2. The Controller calls the Model to retrieve the data.
  3. The Model returns the required data.
  4. The View receives the data from the Controller and displays it.

Example: Blog System (View in Laravel Blade)

<!-- resources/views/blog/index.blade.php -->
@extends('layouts.app')

@section('content')
    <h1>Blog Posts</h1>
    @foreach ($posts as $post)
        <div>
            <h2>{{ $post->title }}</h2>
            <p>{{ $post->content }}</p>
        </div>
    @endforeach
@endsection

🔹 @foreach: Loops through the list of blog posts and displays them.
🔹 {{ $post->title }}: Outputs the title of the blog post.


Conclusion

✔ The View is responsible for presentation but does not process data.
✔ It ensures a clear separation between logic and display.
✔ Using templates or frontend technologies (e.g., Vue.js, React), the View can be dynamically rendered.

 


Model

The Model is the data and logic layer in the MVC architecture. It manages the application's data and ensures that it is correctly stored, retrieved, and processed.


Main Responsibilities of the Model

Data Management: Stores and handles data, often in a database.
Business Logic: Contains rules and calculations (e.g., discount calculation for orders).
Data Validation: Checks if input is correct (e.g., if an email address is valid).
Database Communication: Performs CRUD operations (Create, Read, Update, Delete).


How Does the Model Work in MVC?

  1. The user sends a request (e.g., "Show all blog posts").
  2. The Controller processes the request and calls the Model.
  3. The Model queries the database and returns the data.
  4. The Controller passes the data to the View for display.

Example: Blog System (Model in Laravel)

class BlogPost extends Model {
    protected $fillable = ['title', 'content']; // Erlaubte Felder für Massenverarbeitung

    // Beziehung: Ein Blogpost gehört zu einem Benutzer
    public function user() {
        return $this->belongsTo(User::class);
    }
}

🔹 fillable: Specifies which fields can be saved.
🔹 belongsTo(User::class): Indicates that each blog post belongs to a user.


Conclusion

✔ The Model handles all data and business logic of the application.
✔ It ensures a clear separation between data and presentation.
Changes to the data structure only need to be made in the Model, not throughout the entire application.

 


Controller

A Controller is a key component in the Model-View-Controller (MVC) architecture. It acts as an intermediary between the user interface (View) and the business logic or data (Model).

Functions of a Controller

  1. Handling User Input

    • The controller receives requests (e.g., from a web form or an API call).
  2. Processing the Request

    • It analyzes the input and decides which action to take.
    • If necessary, it validates the data.
  3. Interacting with the Model

    • The controller forwards the request to the model to fetch, update, or store data.
  4. Updating the View

    • Once the model processes the request, the controller passes the data to the view.
    • The view is then updated with the new information.

Example: Blog System

Suppose a user wants to create a new blog post:

  1. The user fills out a form and clicks "Save" (input to the controller).
  2. The controller receives the request, validates the input, and sends it to the model.
  3. The model stores the post in the database.
  4. The controller retrieves the updated list of posts and sends it to the view.
  5. The view displays the new blog post.

Example Code in PHP (Laravel)

class BlogController extends Controller {
    public function store(Request $request) {
        // Validierung der Benutzereingabe
        $request->validate([
            'title' => 'required|max:255',
            'content' => 'required',
        ]);

        // Neues Blog-Post-Model erstellen und speichern
        BlogPost::create([
            'title' => $request->input('title'),
            'content' => $request->input('content'),
        ]);

        // Weiterleitung zur Blog-Übersicht
        return redirect()->route('blog.index')->with('success', 'Post erstellt!');
    }
}

Conclusion

✔ A controller manages the flow of an application and separates business logic from presentation.
✔ It ensures clean code structure, as each component (Model, View, Controller) has a specific responsibility.
✔ Modern frameworks like Laravel, Django, or ASP.NET often include built-in routing mechanisms that automatically direct requests to the appropriate controllers.

 


Model View Controller - MVC

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:

 


Catalyst Web Framework

The Catalyst Framework is a flexible and powerful web framework for Perl. It enables the development of scalable and maintainable web applications and follows the Model-View-Controller (MVC) design pattern.

Key Features of Catalyst

MVC Architecture – Clear separation of business logic, presentation, and data management
Flexibility – Supports various templating systems and ORM solutions like DBIx::Class
Extensibility – Many plugins and modules available
Asynchronous Capabilities – Can be integrated with event-driven architectures
REST APIs & WebSockets – Support for modern web technologies

Use Cases

 


Perl

Perl is a powerful, flexible, and versatile programming language, originally designed for text processing and system administration. The name stands for "Practical Extraction and Report Language", though this was a retroactive acronym.

Key Features of Perl:

Dynamic & flexible – Perl is not strictly typed and supports multiple programming paradigms.
Strong in text processing – Ideal for regular expressions, data manipulation, and parsing.
Cross-platform – Runs on Windows, Linux, macOS, and more.
Large community & CPAN – The Comprehensive Perl Archive Network (CPAN) offers thousands of ready-to-use modules and extensions.
Use cases – Commonly used for web development (CGI scripts), system administration, network programming, and data analysis.

A Simple Perl Program:

#!/usr/bin/perl
use strict;
use warnings;

print "Hello, World!\n";

Entity Header

Entity headers are HTTP headers that provide information about the body of a message. They can appear in both requests and responses, describing properties of the content such as type, length, encoding, or last modification date.

Important Entity Headers:

1. Content-Type

  • Specifies the media type (MIME type) of the content.
  • Example:
Content-Type: application/json; charset=UTF-8

2. Content-Length

  • Indicates the size of the content in bytes.
  • Example:
Content-Length: 1024

3. Content-Encoding

  • Shows if the content has been compressed (e.g., gzip).
  • Example:
Content-Encoding: gzip

4. Content-Language

  • Specifies the language of the content.
  • Example:
Content-Language: de-DE

5. Cache-Location

  • Indicates the URL or storage location of the actual resource.
  • Example:
Content-Location: /files/document.pdf

6. Last-Modified

  • Specifies when the content was last changed.
  • Example:
Last-Modified: Tue, 30 Jan 2025 14:20:00 GMT

7. ETag

  • A unique identifier for a version of the resource, useful for caching.
  • Example:
ETag: "abc123xyz"

8. Expires

  • Indicates when the content should be considered outdated.
  • Example:
Expires: Fri, 02 Feb 2025 12:00:00 GMT

9. Allow

  • Lists the allowed HTTP methods for a resource.
  • Example:
Allow: GET, POST, HEAD

10. Refresh  (Not standardized but often used)

  • Instructs the browser to refresh the page after a specified time.
  • Example:
Refresh: 10; url=https://example.com

These headers help describe the content of an HTTP message, optimize caching strategies, and ensure correct rendering.




Response Headers

Response headers are HTTP headers sent from the server to the client. They contain information about the server’s response, such as status codes, content types, security policies, or caching rules.

Important Response Headers:

1. Server

  • Indicates which software or technology the server is using.
  • Example:
Server: Apache/2.4.41 (Ubuntu)

2. Date

  • Specifies the date and time of the server’s response in GMT format.
  • Example:
Date: Wed, 31 Jan 2025 12:34:56 GMT

3. Content-Type

  • Defines the media type of the response.
  • Example:
Content-Type: text/html; charset=UTF-8

4. Content-Length

  • Indicates the size of the response in bytes.
  • Example:
Content-Length: 3456

5. Cache-Control

  • Determines the caching behavior of the response.
  • Example:
Cache-Control: max-age=3600, must-revalidate

6. Set-Cookie

  • Sends cookies to the client for storage and future requests.
  • Example:
Set-Cookie: sessionId=abc123; Path=/; Secure; HttpOnly

7. ETag

  • A unique identifier for a specific version of a resource, used for caching optimization.
  • Example:
ETag: "5d8c72a5f8d9f"

8. Location

  • Specifies a redirect URL if a resource has moved.
  • Example:
Location: https://www.new-url.com/

9. Access-Control-Allow-Origin

  • Enables cross-origin requests (CORS).
  • Example:
Access-Control-Allow-Origin: *

10. Strict-Transport-Security (HSTS)

  • Enforces HTTPS for future requests.
  • Example:
Strict-Transport-Security: max-age=31536000; includeSubDomains

Response headers help the client interpret the received response correctly, enforce security measures, and optimize caching strategies.


HTTP Request headers

Request headers are HTTP headers sent by a client (e.g., a web browser or API request) to the server, providing additional information about the request, the client, or the desired content.

Important Request Headers:

1. Host

  • Specifies the target domain or IP address of the server.
  • Example:
Host: www.example.com

2. User-Agent

  • Contains information about the client, such as browser type or operating system.
  • Example:
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)

3. Accept

  • Defines which content types the client can accept.
  • Example:
Accept: text/html, application/json

4. Accept-Language

  • Specifies the client's preferred language(s).
  • Example:
Accept-Language: de-DE, en-US

5. Accept-Encoding

  • Indicates which compression formats the client supports.
  • Example:
Accept-Encoding: gzip, deflate, br

6. Referer

  • Provides the previous page from which the user navigated.
  • Example:
Referer: https://www.google.com/

7. Authorization

  • Used for authentication when accessing protected resources.
  • Example(Basic Auth):
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

8. Cookie

  • Contains cookies previously set by the server.
  • Example:
Cookie: sessionId=abc123; theme=dark

9. Content-Type (for POST/PUT-Anfragen)

  • Specifies the data format of the request body.
  • Example:
Content-Type: application/json

10. Origin

  • Indicates the origin URL and is often used in Cross-Origin requests.
  • Example:
Origin: https://www.example.com

These headers help the server understand the request and respond accordingly by providing details about the client, preferred content, and security aspects.


Random Tech

Kubernetes


kubernetes.png