bg_image
header

Vite

Vite ist ein modernes Build-Tool und Entwicklungsserver für Webanwendungen, das von Evan You, dem Schöpfer von Vue.js, entwickelt wurde. Es ist darauf ausgelegt, die Entwicklungs- und Build-Prozesse schneller und effizienter zu gestalten. Der Name "Vite" stammt vom französischen Wort für "schnell" und spiegelt das Hauptziel der Software wider: eine blitzschnelle Entwicklungsumgebung.

Die Hauptmerkmale von Vite sind:

  1. Schneller Entwicklungsserver: Vite nutzt die modernen ES-Module (ESM) und bietet durch diese Technik einen ultraschnellen Entwicklungsserver. Es wird nur das neueste Modul geladen, was die Initialisierung deutlich schneller macht als traditionelle Bundler.

  2. Hot Module Replacement (HMR): Der HMR funktioniert extrem schnell, indem er nur die geänderten Module aktualisiert, ohne die gesamte Anwendung neu zu laden.

  3. Modernes Build-System: Vite verwendet Rollup unter der Haube, um die endgültige Produktion zu bundeln, was optimierte und effizientere Builds ermöglicht.

  4. Zero-Konfiguration: Vite ist sehr benutzerfreundlich und erfordert keine umfangreiche Konfiguration. Es funktioniert sofort mit der Standard-Konfiguration, wobei es viele gängige Web-Technologien out-of-the-box unterstützt (z. B. Vue.js, React, TypeScript, CSS-Preprozessoren usw.).

  5. Optimierte Produktion: Für die Produktion wird Rollup verwendet, das für seine effizienten und optimierten Bundles bekannt ist.

Vite richtet sich hauptsächlich an moderne Web-Anwendungen und ist besonders beliebt bei Entwicklern, die mit Frameworks wie Vue, React oder Svelte arbeiten.

 


Partial Mock

Ein Partial Mock (teilweises Mocking) ist eine Technik beim Testen von Software, bei der nur ein Teil eines Objekts durch ein Mock ersetzt wird, während der Rest der echten Implementierung erhalten bleibt. Dies ist besonders nützlich, wenn du nur bestimmte Methoden eines Objekts stubben oder mocken möchtest, während andere Methoden normal ausgeführt werden.

Wann wird ein Partial Mock verwendet?

  • Wenn du eine Klasse testen möchtest, aber bestimmte Methoden von ihr isolieren musst.

  • Wenn einige Methoden schwer zu testen sind (z. B. weil sie externe Abhängigkeiten haben), aber andere weiterhin mit ihrer echten Logik arbeiten sollen.

  • Wenn du nur einige Methoden stubben möchtest, um den Testablauf zu steuern.

Beispiel in PHP mit PHPUnit

Angenommen, du hast eine Klasse Calculator, aber möchtest die Methode multiply() mocken, während add() normal funktioniert.

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }

    public function multiply($a, $b) {
        return $a * $b;
    }
}

// PHPUnit Test mit Partial Mock
class CalculatorTest extends \PHPUnit\Framework\TestCase {
    public function testPartialMock() {
        // Partial Mock von Calculator
        $calculator = $this->getMockBuilder(Calculator::class)
                           ->onlyMethods(['multiply']) // Nur diese Methode mocken
                           ->getMock();

        // Definiere Verhalten für multiply()
        $calculator->method('multiply')->willReturn(10);

        // Teste echte Methode add()
        $this->assertEquals(5, $calculator->add(2, 3));

        // Teste gemockte Methode multiply()
        $this->assertEquals(10, $calculator->multiply(2, 3));
    }
}

Hier bleibt add() unverändert und arbeitet mit der echten Implementierung, während multiply() immer 10 zurückgibt.

Fazit

Partial Mocks sind nützlich, wenn du Teile einer Klasse isolieren möchtest, ohne sie vollständig zu ersetzen. Sie helfen, Tests stabiler und effizienter zu machen, indem nur bestimmte Methoden gemockt werden.


Salesforce Apex

Salesforce Apex ist eine objektorientierte Programmiersprache, die speziell für die Salesforce-Plattform entwickelt wurde. Sie ähnelt Java und wird hauptsächlich verwendet, um benutzerdefinierte Geschäftslogik, Automatisierungen und Integrationen in Salesforce zu implementieren.

Wichtige Merkmale von Apex:

  • Cloud-basiert: Läuft ausschließlich auf den Servern von Salesforce.

  • Syntaxähnlichkeit zu Java: Wer Java kennt, kann Apex schnell lernen.

  • Eng mit der Salesforce-Datenbank (SOQL & SOSL) verknüpft: Ermöglicht direkte Datenabfragen und Manipulationen.

  • Ereignisgesteuert: Wird oft durch Salesforce-Trigger (z. B. Änderungen an Datensätzen) ausgeführt.

  • Governor Limits: Salesforce begrenzt Ressourcenverbrauch (z. B. maximale Anzahl von SOQL-Abfragen pro Transaktion), um die Performance der Plattform zu sichern.

Verwendung von Apex:

  • Triggers: Automatische Aktionen bei Änderungen an Datensätzen.

  • Batch-Prozesse: Verarbeitung großer Datenmengen in Hintergrundjobs.

  • Web Services & API-Integrationen: Kommunikation mit externen Systemen.

  • Custom Controllers für Visualforce & Lightning: Steuerung von Benutzeroberflächen.

 


Memcached

Memcached ist ein verteiltes In-Memory-Caching-System, das häufig zur Beschleunigung von Webanwendungen eingesetzt wird. Es speichert häufig abgefragte Daten temporär im Arbeitsspeicher, um teure Datenbankabfragen oder API-Aufrufe zu vermeiden.

Wichtige Eigenschaften von Memcached:

  • Schlüssel-Wert-Speicher: Daten werden als Key-Value-Paare gespeichert.

  • In-Memory: Läuft vollständig im RAM, daher extrem schnell.

  • Verteilt: Unterstützt mehrere Server (Cluster), um die Last zu verteilen.

  • Einfach: Bietet eine minimalistische API mit grundlegenden Operationen wie set, get, delete.

  • Eviction (Ablaufstrategie): Verwendet LRU (Least Recently Used), um alte Daten bei Speicherüberlastung zu löschen.

Typische Anwendungsfälle:

  • Caching von Datenbankabfragen: Reduziert die Last auf Datenbanken wie MySQL oder PostgreSQL.

  • Session-Management: Speichert Benutzersitzungen bei skalierbaren Web-Apps.

  • Temporäre Datenspeicherung: Z.B. für API-Rate-Limiting oder kurze Zwischenspeicher.

Memcached vs. Redis:

  • Memcached: Schneller bei einfachen Key-Value-Speichern, skaliert gut horizontal.

  • Redis: Bietet mehr Features wie persistente Speicherung, Listen, Hashes, Sets und Pub/Sub.

Installation & Nutzung (Beispiel für Linux):

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

Mit PHP oder Python kann Memcached über entsprechende Libraries verwendet werden.

 


Crawler

Ein Crawler (auch Webcrawler, Spider oder Bot genannt) ist ein automatisiertes Programm, das das Internet durchsucht und Webseiten analysiert. Es folgt Links von Seite zu Seite und sammelt dabei Informationen.

Einsatzgebiete von Crawlern:

  1. Suchmaschinen (z. B. Googlebot von Google) – Indizieren Webseiten, damit sie in Suchmaschinen-Ergebnissen erscheinen.

  2. Preisvergleichsportale – Durchsuchen Onlineshops nach aktuellen Preisen und Produkten.

  3. SEO-Tools – Analysieren Webseiten auf technische Fehler oder Verbesserungspotenzial.

  4. Datenanalyse & Monitoring – Beobachten Webseiteninhalte, z. B. für Marktforschung oder Konkurrenzanalysen.

  5. Archivierung – Speichern Webseiten für spätere Referenzen (z. B. Internet Archive).

Funktionsweise eines Crawlers:

  1. Startet mit einer Liste von URLs.

  2. Ruft Webseiten auf und speichert Inhalte (Text, Metadaten, Links).

  3. Folgt den Links auf den Seiten und wiederholt den Vorgang.

  4. Speichert oder verarbeitet die gesammelten Daten je nach Zweck.

Viele Webseiten setzen die robots.txt-Datei ein, um zu steuern, welche Inhalte von Crawlern besucht oder ignoriert werden sollen.

 


Internationalized Resource Identifier - IRI

Ein Internationalized Resource Identifier (IRI) ist eine erweiterte Version eines Uniform Resource Identifier (URI), die Unicode-Zeichen außerhalb des ASCII-Zeichensatzes unterstützt. Dadurch können auch nicht-lateinische Schriftzeichen (z. B. chinesische, arabische oder kyrillische Zeichen) sowie Sonderzeichen in Webadressen und anderen Identifikatoren verwendet werden.

Wichtige Merkmale von IRIs:

  1. Unicode-Unterstützung: Während URIs auf ASCII (also Zeichen von A-Z, 0-9, -, . und _) beschränkt sind, erlauben IRIs Zeichen aus dem gesamten Unicode-Zeichensatz.
  2. Rückwärtskompatibilität: Jeder IRI kann in einen URI umgewandelt werden, indem nicht-ASCII-Zeichen in eine Punycode- oder Prozent-kodierte Form überführt werden.
  3. Anwendung in Web-Technologien: IRIs ermöglichen internationalisierte Domänennamen (IDNs), Pfade und Abfrageparameter in URLs, was die Webnutzung für nicht-englische Sprachen erheblich verbessert.

Beispiel:

  • IRI: https://de.wikipedia.org/wiki/Überblick
  • Entsprechender URI: https://de.wikipedia.org/wiki/%C3%9Cberblick
    (Hier wird Ü als %C3%9C kodiert)

Standardisierung:

IRIs sind in RFC 3987 definiert und werden in modernen Webtechnologien wie HTML5, XML und RDF unterstützt.

Fazit:

IRIs machen das Internet sprachlich inklusiver, indem sie Webseiten und Ressourcen mit nicht-lateinischen Zeichen leichter zugänglich machen.

 


System Under Test - SUT

Ein SUT (System Under Test) ist das System oder die Komponente, die in einem Testprozess geprüft wird. Der Begriff wird häufig in der Softwareentwicklung und Qualitätssicherung verwendet.

Bedeutung und Anwendung:

  • In Softwaretests bezeichnet der SUT das gesamte Programm, ein einzelnes Modul oder eine spezifische Funktion, die getestet wird.
  • In Hardwaretests kann der SUT ein elektronisches Gerät oder eine Maschine sein, die überprüft wird.
  • In automatisierten Tests wird der SUT oft mit Testframeworks und Tools getestet, um Fehler oder unerwartetes Verhalten zu identifizieren.

Ein typischer Testprozess umfasst:

  1. Definition der Testfälle basierend auf den Anforderungen.
  2. Ausführung der Tests auf dem SUT.
  3. Überprüfung der Testergebnisse und Abgleich mit den erwarteten Werten.

 


Whoops

Die PHP-Bibliothek Whoops ist ein leistungsstarkes und benutzerfreundliches Fehlermanagement-Tool für PHP-Anwendungen. Sie sorgt dafür, dass Fehler in einer ansprechenden und übersichtlichen Weise dargestellt werden, was die Fehlersuche und -behebung erleichtert.

Hauptfunktionen von Whoops

Schöne, interaktive Fehlerseiten
Detaillierte Stack-Traces mit Code-Vorschau
Einfache Integration in bestehende PHP-Projekte
Unterstützung für verschiedene Frameworks (Laravel, Symfony, Slim, etc.)
Anpassbar durch eigene Handler und Logger


Installation

Whoops kann mit Composer installiert werden:

composer require filp/whoops

Grundlegende Nutzung

Hier ist ein einfaches Beispiel, wie du Whoops in deinem PHP-Projekt aktivieren kannst:

require 'vendor/autoload.php';

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

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

// Erzeugt einen Fehler (z. B. eine nicht definierte Variable aufrufen)
echo $undefinedVariable;

Falls ein Fehler auftritt, zeigt Whoops eine übersichtliche Debug-Seite an.


Anpassung und Erweiterung

Du kannst Whoops auch erweitern, z. B. indem du eine eigene Fehlerbehandlung hinzufügst:

use Whoops\Handler\CallbackHandler;

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

Diese Variante loggt Fehler in eine Datei, anstatt sie direkt anzuzeigen.


Einsatzgebiete

Whoops wird oft in Entwicklungsumgebungen verwendet, um schnell auf Fehler zu reagieren. In Produktionsumgebungen sollte es jedoch deaktiviert oder durch eine benutzerdefinierte Fehlerseite ersetzt werden.


Fetch API

Die Fetch API ist eine moderne JavaScript-Schnittstelle für das Abrufen von Ressourcen über das Netzwerk, z. B. für HTTP-Requests an eine API oder das Laden von Daten von einem Server. Sie ersetzt weitgehend die ältere XMLHttpRequest-Methode und bietet eine einfachere, flexiblere und leistungsfähigere Möglichkeit, Netzwerkabfragen zu verwalten.

Grundlegende Funktionsweise

  • Die Fetch API basiert auf Promises, was asynchrones Arbeiten erleichtert.
  • Sie ermöglicht den Abruf von Daten in verschiedenen Formaten wie JSON, Text oder Blob.
  • Fetch arbeitet standardmäßig mit der GET-Methode, kann aber auch für POST, PUT, DELETE und andere HTTP-Methoden verwendet werden.

Ein einfaches Beispiel

fetch('https://jsonplaceholder.typicode.com/posts/1')
  .then(response => response.json()) // Antwort als JSON umwandeln
  .then(data => console.log(data)) // Daten ausgeben
  .catch(error => console.error('Fehler:', error)); // Fehlerbehandlung

Ein Request mit POST-Methode

fetch('https://jsonplaceholder.typicode.com/posts', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ title: 'Neuer Beitrag', body: 'Inhalt des Beitrags', userId: 1 })
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Fehler:', error));

Vorteile der Fetch API

✅ Einfachere Syntax als XMLHttpRequest
✅ Unterstützt async/await für bessere Lesbarkeit
✅ Flexibles Handling von Requests und Responses
✅ Bessere Fehlerbehandlung durch Promises

Die Fetch API ist mittlerweile in allen modernen Browsern verfügbar und eine essentielle Technik für die Webentwicklung.

 

 


Single Page Application - SPA

Eine Single Page Application (SPA) ist eine Webanwendung, die vollständig innerhalb einer einzigen HTML-Seite läuft. Statt bei jeder Benutzerinteraktion eine neue Seite vom Server zu laden, werden Inhalte dynamisch über JavaScript aktualisiert. Dies führt zu einer schnellen, flüssigen Benutzererfahrung, ähnlich wie bei nativen Apps.

Merkmale einer SPA:

  • Dynamisches Nachladen von Inhalten: Neue Inhalte werden per AJAX oder Fetch API geladen, ohne die Seite neu zu laden.
  • Client-seitiges Routing: Die Navigation erfolgt über JavaScript (z. B. mit React Router oder Vue Router).
  • State-Management: SPAs nutzen oft Bibliotheken wie Redux, Vuex oder Zustand zur Verwaltung des Anwendungszustands.
  • Trennung von Frontend und Backend: Das Backend dient meist nur als API (z. B. REST oder GraphQL).

Vorteile:

✅ Schnelle Ladezeiten nach dem ersten Aufruf
✅ Bessere Benutzererfahrung (keine Seiten-Neuladungen)
✅ Offline-Funktionalität durch Service Worker möglich

Nachteile:

❌ Erster Ladevorgang kann langsam sein (größerer JavaScript-Bundle)
SEO-Probleme (da Inhalte oft erst per JavaScript geladen werden)
❌ Komplexere Implementierung, insbesondere bei Sicherheit und Routing

Typische Frameworks für SPAs sind React, Angular und Vue.js.