In this article, I’ll walk you through why PHP is such a big deal in WordPress, how understanding the basics can help you (even if you’re not coding full-time), and offer some easy-to-grasp examples that’ll hopefully spark your interest in digging a little deeper. I’ll also sprinkle in a few handy links to some of our other blog posts on related topics so you can continue your learning journey. Let’s get started!

1. A Quick Refresher: What’s WordPress?

WordPress is often described as a Content Management System (CMS). Essentially, it’s software that makes it easy to build and manage websites without needing a PhD in Computer Science. You can choose from thousands of themes, install plugins for practically any feature under the sun, and create pages and posts with minimal fuss.

• For designers: This means you can focus on aesthetics, typography, and layout without wrestling with raw code day in and day out.
• For content managers: It means you can upload and schedule content effortlessly, keep track of your SEO best practices, and handle user permissions without getting lost in the weeds of database queries.

But behind all these user-friendly features is a powerful programming language called PHP. This is where things get interesting.

2. PHP in a Nutshell

PHP (Hypertext Preprocessor) is a popular scripting language primarily used in web development. Think of it like the “brains” that process user requests, query databases, and determine what content to serve up in your browser.

Why PHP Matters

• Server-Side Execution: While JavaScript usually runs in your browser, PHP does its work on the server. This means tasks like processing form submissions, interacting with databases, or generating dynamic content happen before the page even reaches your computer.
• Wide Adoption: PHP powers a significant portion of the web—WordPress being one of its most famous success stories. Its large community means it’s well-documented, regularly updated, and has a wide ecosystem of tools and frameworks.
• Easy to Learn, Hard to Master: PHP has a reputation for being relatively easy to pick up. However, truly mastering it (especially with modern frameworks and best practices) can take years.

At WATA Factory, we work on a broad range of PHP-based projects, from WordPress websites to custom applications using frameworks like Symfony and Laravel. If you’re curious about how we tackle modernization of older PHP projects, we’ve covered that in a blog post about modernizing PHP legacy projects with Symfony—you can see how these different tools and frameworks all tie together in the broader PHP ecosystem.

3. How PHP Powers WordPress

So, how exactly does PHP fit into WordPress? Here’s the simplified breakdown:

1. Core Files: WordPress itself is mostly written in PHP. Every time you install WordPress, you’re downloading a collection of PHP files that handle user logins, post creation, media uploading, and more.
2. Themes: Your WordPress theme is also built using PHP. Those .php files you see in a theme folder (like header.php, footer.php, functions.php) determine your site’s layout and functionality.
3. Plugins: Plugins extend WordPress, and guess what—they’re also primarily PHP-based. Whether it’s an SEO plugin, a security plugin, or a contact form plugin, there’s PHP code under the hood.

Each time someone visits your site, WordPress’s PHP files run on the server. They query the database (also typically MySQL or MariaDB, sometimes others), retrieve the right content, and package it into an HTML page that gets sent to the browser. For a deeper dive on databases, we have a new post about NoSQL Databases—a bit more advanced, but it shows the variety of database solutions you might run into in modern web development.

4. Why Non-Developers Should Care

You might be thinking, “I’m not a coder, so why should I bother with all this PHP talk?” Great question!

• Better Collaboration: Understanding the fundamentals of how PHP works in WordPress can help you communicate more effectively with developers. If you know what’s happening behind the scenes, it’s easier to explain a design element or bug you’re seeing.
• Troubleshooting: Often, WordPress errors might be something as simple as a missing semicolon or conflicting plugin. If you can glance at PHP error logs or know how to disable a problematic plugin temporarily, you can solve issues faster.
• Site Performance: WordPress performance is heavily influenced by the efficiency of your PHP code. If you’re a content manager, you might not write code, but knowing that large images or heavy plugins affect PHP’s workload gives you insight into how to keep your site running smoothly.
• Security Awareness: A big part of WordPress security involves understanding how plugins and themes interact with PHP. If you’re aware of potential vulnerabilities, you’ll make smarter decisions about what to install and update.

Let’s say you’re a designer who wants to add a custom typeface or tweak the layout. You might dip into the functions.php file or install a plugin that modifies theme elements. Having a basic idea of the file structure and the role PHP plays helps you avoid inadvertently breaking something.

5. A Tiny PHP Example

To keep things concrete, here’s a very short snippet of what a basic PHP function might look like in a WordPress theme’s functions.php:

function watafactory_add_support() {
    // This enables featured images in a WordPress theme
    add_theme_support('post-thumbnails');
    // This adds custom logo support
    add_theme_support('custom-logo');
}
add_action('after_setup_theme', 'watafactory_add_support');

• What it does: This little snippet tells WordPress your theme supports featured images and custom logos.
• Why it matters: If you’re a designer or content manager, you might want to ensure your posts have eye-catching featured images, or that you can easily upload a custom site logo from the WordPress dashboard. Knowing where and how this is done in PHP means you can quickly tweak your theme.

Even if you don’t fully understand every function here, grasping the gist that “this code block registers new features so WordPress can use them” can be powerful.

6. The Role of Plugins (and Why They’re PHP-Driven)

Plugins are essentially mini-applications (written in PHP) that integrate seamlessly with WordPress. If you’ve ever installed a form plugin like Contact Form 7 or an SEO plugin like Yoast, you’ve experienced how plugins can expand WordPress’s capabilities.

• For Developers: Plugins offer an opportunity to build custom functionalities. If a client needs a special booking system or membership login, for example, we can code a plugin that fits right into WordPress’s existing structure.
• For Non-Developers: Installing a plugin is as easy as clicking “Add New,” but understanding that PHP is under the hood can help you pick reputable plugins. Plugins are “mini software,” so you want well-coded and frequently updated ones.

At WATA Factory, we’ve also explored more in-depth WordPress tweaks—like building custom blocks or hooking into WordPress’s REST API. If you want to expand your WordPress knowledge further, you might enjoy reading our Introduction to WordPress Page Builders or our follow-up piece on Core Features and Capabilities of the Leading WordPress Page Builder in 2024. These articles can help you see how developers and designers leverage plugins or page builder solutions for rapid site creation.

7. Themes: The Intersection of Design & PHP

When you install a WordPress theme, you’re basically installing a collection of PHP templates that define how your site looks. Each page—like your blog posts, your homepage, or your contact page—has a corresponding PHP file that dictates its structure.

• For Designers: This is where you live. Colors, fonts, imagery—this is your playground. However, behind every color and font choice is a snippet of PHP telling WordPress “hey, display the site title here” or “generate a list of recent blog posts there.”
• For Content Managers: Ever wonder how your blog post content ends up styled a certain way? That’s the theme’s PHP template at work. Basic familiarity with these template files can help you request changes from developers more precisely.

If you ever feel like taking a peek behind the curtain, you can open up a theme’s header.php, single.php, or footer.php files. They may look a bit confusing at first, but after a few glances, you’ll notice the pattern: HTML + some PHP snippets that dynamically pull in data like post titles, metadata, or your site’s navigation menu.

8. Performance & Security Considerations

Performance

A well-optimized WordPress site can load quickly and handle tons of traffic. A poorly optimized one can buckle under the pressure.

• Caching: PHP code runs on the server each time a page is loaded. But caching plugins can store the finished HTML, reducing how often PHP files need to be executed. This means your site loads faster.
• Code Quality: Clean, well-structured PHP code is easier to maintain and runs more efficiently. If you have dozens of poorly-coded plugins, you’ll likely see performance hits.

Security

PHP’s flexibility is both a blessing and a curse. If not written securely, it can open up vulnerabilities.

• Updates: WordPress regularly releases updates to patch security issues. The same goes for themes and plugins. Keeping them updated ensures you’re protected against known threats.
• Quality Plugins: Not all plugins are created equal. Some might be poorly coded and leave your site open to attacks. Always choose reputable plugins with good reviews and frequent updates.

For a broader sense of how we handle security and best practices in general, you might want to check out our Technology page—it’s got more info on how we approach development and keep sites running securely at WATA Factory.

9. Getting Comfortable with the Basics

Even if your main gig is design or content, you’ll benefit from learning just a smidge of PHP. Here are some beginner-friendly action items:

1. Tinker with a Local Environment: Set up a local WordPress install (using something like MAMP, WAMP, or Local by Flywheel). Poke around the theme files. Try adding a function or two to functions.php.
2. Read & Watch Tutorials: There are countless YouTube channels and blogs dedicated to WordPress theme development. Start small—like customizing your blog layout or adding a custom post type.
3. Practice Safe Experimentation: If you decide to play with code on a live site, make sure you have a backup or a staging environment in place.
4. Study Our Blog Posts: We frequently publish articles on everything from automated testing in PHP projects to advanced front-end frameworks. While not all of them are strictly about WordPress, they will help expand your understanding of modern PHP development practices.

10. Wrapping Up

Learning PHP basics is like finding the missing puzzle piece that lets you see the entire WordPress picture clearly. It’s not just for developers; having a grasp of what’s happening behind the scenes empowers designers, content managers, and site owners to make more informed decisions.

I love that moment when our design team says, “We want this widget to appear here,” and, as a developer, I can open up sidebar.php or functions.php to show them exactly which lines of code handle that. There’s a sense of team synergy when non-developers feel confident enough to peek under the hood. You might not become a full-fledged PHP wizard overnight, but you’ll certainly be able to hold your own in a conversation about how WordPress is structured.

And if you ever need help—from building custom themes and plugins to performing a site-wide performance audit—remember that we at WATA Factory have your back. Our main site is a good starting point to see our services, and our blog is chock-full of insights on the latest in tech, including additional WordPress and PHP tips. Feel free to explore, leave a comment, or reach out if you’d like a deeper dive into any topic.

So go ahead—pop open that functions.php file, install a test plugin, or read a few lines of code. You’d be surprised at how quickly the basics become second nature. WordPress might be user-friendly by design, but a small slice of PHP knowledge can make you unstoppable in the world of content management and site design.

Happy WordPress-ing! If you have any questions or want to chat about all things PHP, don’t hesitate to reach out. We love hearing your thoughts and geek out on new challenges every day.

The post PHP und WordPress: Was du wissen musst (auch wenn du kein Entwickler bist) appeared first on WATA Factory.

Dieses Verfahren ist für PHP-Versionen vor PHP 8.1 gedacht, die den nativen Enum-Typ enthalten. Wir könnten die gleiche Lösung mit wenigen Änderungen mit Enums oder mit einem anderen bestehenden Ansatz behandeln. Viele Projekte verwenden jedoch immer noch PHP 8.0 oder älter und dieser Code ist immer noch nützlich für die Anpassung unserer Enum-Typen in PostgreSQL mit Doctrine und Symfony.

Stell dir vor, du hast einen Typ appointment_status als Enum in deinem alten Datenbankschema wie folgt definiert.

CREATE TYPE public.appointment_status AS ENUM
 ('Open', 'Invited', 'Assigned', 'Unassigned');

Und du verwendest diesen Typ in einer bestimmten Spalte:

CREATE TABLE IF NOT EXISTS public.appointment
  {
 id integer NOT NULL,
 status public.appointment_status NOT NULL DEFAULT 'Open'::public.appointment_status,
 comment character varying(500)
  }

In diesem Artikel erfahren wir also, wie man diese Art von Daten auf einfache Weise handhaben kann.

Erstellen eines abstrakten Enum-Typs

Der erste Schritt ist die Erstellung einer abstrakten Klasse für diese Art von Daten. Mit dieser Abstraktion können wir die Klasse für jedes Enum-Feld wiederverwenden.

schema . ".\"" . $this->getName() . "\""; 
  }  
 
 public function convertToPHPValue($value, AbstractPlatform $platform) 
  {  
 return $value; 
  }  
 
 public function convertToDatabaseValue($value, AbstractPlatform $platform) 
  {  
 if (!in_array($value, $this->getValidValues())) { 
 throw new \InvalidArgumentException("Invalid '".$this->name."' value."); 
  }  
 return $value; 
  }  
 
 public function getName(): string 
  {  
 return $this->name; 
  }  
 
 public function requiresSQLCommentHint(AbstractPlatform $platform): bool 
  {  
 return true; 
  }  
 
 public function getValidValues(): array 
  {  
 return $this->values; 
  }  
 
}  
 

Erstellen des Enum-Typs

Nun musst du den spezifischen Enum-Typ erstellen, der die abstrakte Klasse erweitert:

values = self::$options; 
  }  
 
 public function getValidValues(): array 
  {  
 return self::$options; 
  }  
}  
 

Tipp: Wenn die Liste zu lang ist, kannst du die Klasse in zwei Dateien aufteilen; die Logik auf der einen Seite und die Werte auf der anderen, so erhältst du besser wartbare Klassen

values = CitizenshipEnum::getValues();
  }
 public function getValidValues(): array
  {
 return CitizenshipEnum::getValues();
  }
}
namespace App\Infrastructure\Persistence\Doctrine\DBAL\Enums;
class CitizenshipEnum
{
 protected static array $values = [
 'Ohne Angabe',
 'Afghanistan',
 'Algerien',
 'Andorra',
 'Angola',
 '[....]',
 'Vietnam',
 'Zentralafrikanische Republik',
 'Zypern',
 ];
 public static function getValues(): array
  {
 return self::$values;
  }
}

Definieren als Typ in Doctrine

An diesem Punkt müssen wir Symfony mitteilen, dass wir einen neuen Datentyp haben. Das einzige, was noch aussteht, ist eine Map in Doctrine und wir müssen ihr sagen „Eh, dieser Datentyp ist etwas Besonderes!“. Bearbeite die doctrine.yml und füge diese Zeilen hinzu:

doctrine: 
 dbal: 

 […] 
 mapping_types: 
 appointment_status: appointment_status 

 

 types: 
 appointment_status: App\..\AppointmentStatusType 

 

Mapping Entität mit benutzerdefiniertem Datentyp

Ja! Doctrine kennt jetzt die einzigen zulässigen Werte für den Status. In unserer XML-Datei für das Mapping von Entitäten können wir jetzt verwenden:

<!-- status -->
<field name="status" type="appointment_status" column="status">
    <options>
        <option name="default">Open</option>
    </options>
</field> 

In unserer Entitätsdatei müssen wir „string“ verwenden und uns nicht um den Datentyp kümmern… Doctrine macht alles für uns:

private string $status; 

Verwendung von Asserts zur Validierung von Eingaben

Wenn wir nun eine Eingabe mit einem speziellen Datentyp validieren wollen, können wir diese Einschränkung mit Symfony/Validator verwenden. Dies ist nützlich für die Validierung von Formularen oder POST-Aufrufen.

status: 
  - NotBlank: ~ 
  - Choice: { callback: [ \[..]ProductStatusType, getValidValues] }  

Und Symfony prüft, ob der angegebene Wert in den zugelassenen Werten in unserem benutzerdefinierten Datentyp definiert ist…. Zauberei! ie Callback-Definition ruft die Methode getValidValues() auf und prüft, ob der angegebene Wert ein gültiger Wert ist.

Symfony ist großartig!

The post Arbeiten mit Enum-Typen in Symfony und PostgreSQL appeared first on WATA Factory.

In diesem Artikel werden wir über Codeception sprechen, eines der Tools, welches wir zum automatisierten Testing in unseren PHP implementierten Webprojekten verwenden.

Was ist automatisiertes Testing?

Wenn wir im Bereich des Softwaretestens von automatisiertem Testen sprechen, möchten wir erreichen, dass manuelle Tests unbeaufsichtigt ausgeführt werden können, mit Hilfe eines Tools, welches den Prozess automatisch durchführt und verbessert, ohne jedoch den Nutzen des manuellen Testens zu 100% zu ersetzen. Wir berichteten hierüber bereits in einem früheren Artikel.

Wenn wir die Tests so gestalten können, dass sie von einem Computer ausgeführt werden, dann erreichen wir eine kontinuierliche Durchführung der Tests während der Weiterentwicklung der Anwendung.

Warum ist automatisiertes Testing für uns interessant?

Bei WATA Factory sahen wir die Notwendigkeit, diese Art von Tests zu implementieren, da die Entwicklung unserer Projekte neue Funktionalitäten erforderte, die zusammen mit den bereits Bestehenden getestet werden mussten, um die Qualität unserer Produkte weiterhin zu gewährleisten.

Die Automatisierung von Tests bringt eine Reihe von Vorteilen mit sich, mit deren Hilfe das Qualitätsniveau des Produkts erhöht und seine Kosten gesenkt werden, da die Wiederholung von Tests keine große Zeitinvestition in den Phasen der Verbesserung oder Entwicklung des Produkts erfordert.

Einige der Vorteile, die wir in der WATA Factory durch die Implementierung von automatisierten Tests erreicht haben, sind:

• Automatische Überprüfung der Einhaltung der definierten Vorgaben unter Anwendung von BDD (Behavior Driven Development). Einer der großen Vorteile hiervon ist die Nutzung einer gemeinsamen Sprache zwischen Kunden und Entwickler-Team, um somit zu bestätigen, dass das Verhalten des Codes aus Sicht des Benutzers korrekt ist.
• Reduktion der Anzahl von Bugs, da wir sicherstellen, dass sowohl die neue als auch die alte Funktionalität weiterhin korrekt funktioniert.
• Zeitersparnis beim Testen, da wir wiederkehrende Aufgaben vermeiden, und sicherstellen, dass Änderungen in unserem Programm keine anderen Bereiche des Systems beeinflussen.
• die Erstellung von solider Dokumentation.
• Die Teamarbeit einfacher und sicherer zu machen.

Um mit der Entwicklung des automatisierten Testings zu beginnen, informierten wir uns über verschiedene Testing-Frameworks und stießen auf Codeception, welches alles was wir brauchten, in einem einzigen Tool vereinte.

Was ist Codeception und wie kann man es installieren?

Codeception ist ein PHP-Testframework, das zum Ziel hat, lesbare Tests zu erstellen und die Vorgänge aus der Sicht des Benutzers zu beschreiben. Es erlaubt uns, Akzeptanz-, Funktions- und Unit-Tests durchzuführen.

Der Schlüssel zu Codeception ist seine Mitwirkenden (Actors). Codeception versteht Tests als Vorgänge, die von einer Person angestoßen werden. Zusammengefasst kann man sagen, dass ein UnitTester Vorgänge startet und den Code testet, ein FunctionalTester die Anwendung als Ganzes testet, und ein AcceptanceTester interagiert mit der Schnittstelle.

Jeder Actor führt sogenannte Steps aus, das sind einzelne Anweisungen innerhalb eines Szenarios. Die Anweisungen, die ein Actor erzeugen kann, sind in Modulen gruppiert: PhpBrowser,WebDriver, DB, FileSystem, etc.

Zur Installation folgen wir den in der offiziellen Dokumentationbeschriebenen Schritten.

Bei der Installation wird ein Ordner mit dem Namen tests angelegt, und innerhalb dieses Ordners wird eine Grundstruktur für die Codierung der verschiedenen Testtypen erstellt.

Als Beispiel werden wir den klassischen Login testen. Obwohl es in diesem Test noch mehr Szenarien gibt, zeigen wir nur einige von ihnen, um nicht allzu sehr auszuschweifen.

Um den Test zu erstellen, führt man folgenden Befehl aus:

php vendor/bin/codecept g:feature acceptance Login

Dadurch wird eine ‚.feature‚-Datei erstellt, in der wir unsere User Story in einer formalen Sprache namens Gherkin schreiben, mit der Besonderheit, dass wir diese Szenarien als automatisierte Tests ausführen können.

Feature: Login page
Check that the user can access correctly with correct credentials, in other case a warning text is shown.
 
Scenario: User inserts empty password and empty username
   Given I am on login page
   When I fill fields with empty value
     And I click on login button
   Then I see the entered user data are not correct
 
Scenario: Successful access with valid credencials
   Given I am on login page
   When I fill the fields with correct credencials
     And I click on login button
   Then I see Welcome Dummy Name

Szenarien werden Schritt für Schritt unter der Verwendung von GIVEN-WHEN-THEN Kriterien geschrieben.

• Der GIVEN-Teil ist die Vorbedingung für den Test. Von wo aus begonnen wird
• Der Teil WHEN ist das spezifische Verhalten, also die Aktionen, die wir brauchen.
• Und schließlich THEN, der Teil, in dem wir das erwartete Ergebnis erhalten.

Definieren der Tests

Unser nächster Schritt ist die Definition und Umwandlung der Feature-Datei in einen gültigen Test. Sie wird in der AcceptanceTester-Datei definiert.

Um die notwendigen Schritte zu erhalten, wird der folgende Befehl ausgeführt:

php vendor/bin/codecept gherkin:snippets acceptance

Da wir in der Acceptance Suite sind nutzen wir zum implementieren WebDriver als Modul, was uns die Interaktion mit dem Browser ermöglicht. Das bedeutet, dass wir seine Methoden innerhalb der Testerdatei verwenden können, so wie wir es bei den Skripttests tun können, mit

$I->

Man kann verschiedene Methoden verwenden, die bereits entwickelt wurden (z. B. amOnPage oder click). Jeder Schritt des Gherkin-Szenarios wird um die in Codeception definierten Methoden erweitert.

Wir zeigen nun, wie das in unserem Fall umgesetzt werden kann:

/**
 * @Given I am on login page
 */
public function iAmOnLoginPage()
{
 $I->amOnPage('/login');
}

/**
 * @When I fill fields with empty value
 */
public function iFillFieldsWithEmptyValue()
{
 $I->fillField('#username','');
 $I->fillField('#password','');
}

/**
 * @When I fill the fields with correct credencials
 */
public function iFillTheFieldsWithCorrectCredencials()
{
 $I->fillField('#username','correctUsername');
 $I->fillField('#password','correctPassword');
}

/**
 * @When I click on login button
 */
public function iClickOnLoginButton()
{
 $I->click('Login');
}

/**
 * @Then I see the entered user data are not correct
 */
public function iSeeTheEnteredUserDataAreNotCorrect()
{
 $I->see('the entered user data are not correct');
}

/**
 * @Then I see Welcome Dummy Name
 */
public function iSeeWelcomeDummyName()
{
 $I->see('Welcome Dummy Name,');
}

Schließlich führen wir unsere .feature-Datei mit folgendem Befehl aus

php vendor/bin/codecept run acceptance Login.feature --steps 

um zu sehen, dass Given/When/The mit Teilschritten erweitert wird und das erwartete Ergebnis bei der Ausführung angezeigt wird.

Acceptance Tests (2)
-------------------------------------------------------------
Login page: User inserts empty password and empty username Signature: User inserts empty password and empty username
Test: App/Tests/surveys/Login.feature:User inserts empty password and empty username

Scenario -- 
Check that the user can access correctly with correct credentials, in other case a warning text is shown.

Given i am on login page
 I am on url "https://###########/login"
When i fill fields with empty value
 I fill field "#username"," "
 I fill field "#password"," "
And i click on login button 
 I click "LOGIN"
 I wait 5
Then i see the entered user data are not correct 
 I see "the entered user data are not correct" 
PASSED 

Login page: User inserts proper information - Successful access with valid credencials 
Signature: Successful access with valid credencials 
Test: App/Tests/surveys/articulo_test.feature: Successful access with valid credencials

Scenario --
Check that the user can access correctly with correct credentials, in other case a warning text is shown.

Given i am on login page 
 I am on url "https://########/login"
When i fill the fields with correct credencials 
 I fill field "#username","correctUsername"
 I fill field "#password","correctPassword"
And i click on login button 
 I click "LOGIN"
 I wait 5
Then i see welcome dummy name 
 I see "Welcome Dummy Name,"
PASSED 
-------------------------------------------------------------
Time: 19.57 seconds, Memory: 18.00 MB OK (2 tests, 2 assertions)

Dieses Tool bietet uns viele Vorteile, es hat auch eine Anwendung, bekannt als Webception, in der der Kunde alle Tests vom Browser aus ausführen kann und somit in der Lage ist, den Status der Anwendung zu verfolgen.

The post Einführung in das automatisierte Testing mit Codeception in PHP-Projekten appeared first on WATA Factory.

Um in das Thema einzusteigen, müssen wir uns folgende Fragen stellen: (1) Was verstehen wir unter einem Legacy-Projekt? (2) Wenn es funktioniert, warum sollen wir es ändern? (3) Wie machen wir das? Schauen wir es uns an!

Was verstehen wir unter einem Legacy-Projekt?

Für uns ist ein Legacy–Code (oder Spaghetti-Code) ein Code, bei dem das, was wir für gute Entwicklungspraktiken (Clean Code) halten, weder angewendet wird, noch SOLID-Prinzipien folgt und darüber hinaus keine gute (oder überhaupt gar keine) Testabdeckung hat.

In der Regel handelt es sich bei diesem Code um einen alten Code, der seit mehreren Jahren in Verwendung ist (und mehr oder weniger verlässlich ist), der ohne Framework oder, in dessen Ermangelung, unter Verwendung einer alten Version eines solchen entwickelt wurde (z.B. Symfony 2).

Wenn es funktioniert, warum sollen wir es ändern?

Das ist eine sehr gute Frage, vor allem weil man in unserer Branche oft (manchmal zu oft) hört: was funktioniert, das ändert man nicht.

Die Antwort auf diese Frage ist nicht einfach. Wir sollten die Modernisierung (oder auch nicht) unter dem Aspekt der Nachhaltigkeit und der Stimmigkeit mit den Praktiken, die täglich im Unternehmen durchgeführt werden, in Betracht ziehen.

• Nachhaltigkeit, denn wenn wir von einem laufenden Projekt sprechen erreichen wir jedes Mal, wenn eine neue Entwicklung gemacht wird, nur, dass wir das Monster weiter füttern. Es wird die Zeit kommen in der diese Modernisierung, von der wir gesprochen haben, praktisch unmöglich sein wird, ohne viel Zeit und damit auch Geld zu investieren.

• Stimmigkeit, denn wenn die neuen Projekte einer Reihe von Qualitätsstandards, Einheits- oder Integrationstests usw. folgen, warum werden wir dann laufende Projekte haben, bei denen diese Praktiken nicht angewendet werden, nur weil es sich um ein langfristiges Projekt handelt?

Wie machen wir das?

Wenn wir an diesem Punkt angekommen sind, dann weil wir davon überzeugt sind, dass wir unseren Code erneuern wollen.

Bei WATA Factory arbeiten wir mit Symfony, also werden wir in unserem Fall ein Projekt zu diesem Framework erstellen und den Legacy–Code darin integrieren.

Wenn wir neue Funktionen erarbeiten, werden wir diese im Rahmen des Symfony-Projekts entwickeln. Die alten Funktionen werden in dem, was wir LegacyBundle nennen werden, enthalten sein. Wir setzen diesen Prozess um, indem wir die in diesem Leitfaden (veröffentlicht von Yannick de Lange) aufgeführten Schritte befolgen.

Dieses Bundle wird das gesamte Legacy-Projekt enthalten, und durch Routing werden wir unsere neuen Endpunkte auf den alten Code umleiten, so dass alles weiterhin funktioniert.

Diese Struktur gibt uns die Möglichkeit, nicht das gesamte Projekt auf einmal migrieren zu müssen, mit der damit verbundenen Zeit und dem Risiko, das dies mit sich bringt. Wenn wir bestehende Funktionalitäten modifizieren, müssen wir daran denken sie aus dem Legacy Bereich herauszunehmen und in den neuen Bereich einzufügen. Dies wird dazu führen, dass der Legacy-Teil im Laufe der Zeit immer kleiner wird.

Wenn aus irgendeinem Grund Symfony nicht verwendet wird und der Legacy–Code und der neue Code nicht nebeneinander existieren können, empfehlen wir dem Leitfaden zu folgen, der in dem Buch Modernizing Legacy Applications in PHP von Paul M. Jones enthalten ist.

Paul M. stellt uns Richtlinien zur Modernisierung des Projekts zur Verfügung, einschließlich Autoload, Refactoring des Codes usw.

The post Modernisierung von PHP-Legacy Projekten durch Symfony appeared first on WATA Factory.