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 y WordPress: Lo que necesitas saber (aunque no seas desarrollador) appeared first on WATA Factory.

Este procedimiento está pensado para versiones de PHP anteriores a PHP 8.1 que incluyen el tipo nativo Enum. Podríamos aplicar la misma solución usando enums con unos pocos cambios o usando uno de los otros enfoques existentes. De todas formas, muchos proyectos siguen utilizando PHP 8.0 o anterior y este código sigue siendo útil para personalizar nuestros tipos enum en PostgreSQL con Doctrine y Symfony.

Imagina que has definido un tipo appointment_status como Enum en tu antiguo esquema de base de datos de la siguiente manera.

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

And you use this type in a certain column:

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)
  }

En este artículo aprenderemos a manejar este tipo de datos de forma sencilla.

Creación de un tipo Enum abstracto

El primer paso es crear una clase abstracta para este tipo de datos. Con esta abstracción, podemos reutilizar la clase para cualquier campo enum.

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; 
  }  
 
}  
 

Creación del tipo Enum

Ahora debes seguir la creación del Tipo Enum específico extendiendo la Clase Abstracta:

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

Consejo: Si la lista es demasiado larga, puede dividir la clase en dos archivos; la lógica por un lado, y los valores por otro, y obtener clases más mantenibles

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;
  }
}

Definir como tipo en Doctrina

En este punto tenemos que decirle a Symfony que tenemos un nuevo tipo de datos. Así, lo único pendiente es mapearlo en doctrine y hay que decirle «¡Eh, este tipo de datos es especial!». Edite el doctrine.yml y añada estas líneas:

doctrine: 
 dbal: 

 […] 
 mapping_types: 
 appointment_status: appointment_status 

 

 types: 
 appointment_status: App\..\AppointmentStatusType 

 

Mapeo de entidad con tipo de datos personalizado

¡Sí! Doctrine conoce ahora los únicos valores admitidos para el estado. En nuestro archivo XML de mapeo de entidades, ahora podemos utilizar:

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

En nuestro archivo de entidad, debemos utilizar «string» y no preocuparnos por el tipo de datos… Doctrine lo hace todo por nosotros:

private string $status; 

Uso de assets para validar entradas

Si ahora queremos validar un input con un tipo de dato especial, como vimos antes, podemos usar esta restricción usando Symfony/Validator. Esto es útil para validar formularios o llamadas POST.

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

Y Symfony comprobará si el valor dado está definido en los valores admitidos en nuestro tipo de datos personalizado…. ¡Magia! La definición de callback hace una llamada al método getValidValues() y comprueba si el valor dado es válido.

¡Symfony es genial!

The post Trabajando con Enum Types en Symfony y PostgreSQL appeared first on WATA Factory.

En este artículo hablaremos sobre Codeception, una de las herramientas que utilizamos para la automatización de pruebas para nuestros proyectos web implementados en PHP.

¿Qué es el testing automatizado?

En el ámbito de las pruebas de software, cuando hablamos de testing automatizado, nos referimos a conseguir que las pruebas que se realizan de forma manual puedan ser ejecutadas de forma desatendida, por medio de alguna herramienta que realice el proceso automáticamente, y como ya mencionamos en un articulo anterior, hacer que se mejore el proceso pero sin suplir al 100% el beneficio del testing manual.

Si podemos hacer que los tests sean ejecutados por un ordenador, entonces conseguiremos ejecutarlos de forma continuada según vayamos desarrollando la aplicación.

¿Por qué el testing automático es interesante para nosotros?

En WATA Factory nos vimos en la necesidad de implementar este tipo de pruebas ya que la evolución de nuestros proyectos requería de nuevas funcionalidades, que debían ser probadas en conjunto con las ya existentes para continuar asegurando la calidad de nuestros productos.

La automatización de pruebas trae una serie de beneficios que ayudan a elevar el nivel de calidad del producto y también a disminuir su coste, ya que la repetición de pruebas no supone una inversion grande de tiempo en las fases de mejora o evolución del producto.

Algunas de las ventajas que hemos conseguido en WATA Factory con la implementación de las pruebas automatizadas son:

• Verificar de forma automática que las especificaciones que se han definido se cumplen, haciendo uso de BDD (Behavior Driven Development). Uno de sus grandes beneficios es que nos permite mantener un lenguaje común entre el cliente y el equipo de desarrollo, detallando casos que verifican que el comportamiento del código es correcto desde el punto de vista del usuario.
• Reducir el número de bugs, ya que aseguramos que tanto la nueva funcionalidad como la antigua continúan trabajando correctamente.
• Ganar tiempo probando, ya que evitamos las tareas repetitivas, y aseguramos que los nuevos cambios en nuestra aplicación no afectan en otras partes del sistema.
• Crear una buena documentación.
• Y hacer que el trabajo en equipo sea más sencillo y seguro.

Para comenzar con el desarrollo de las pruebas automatizadas estuvimos investigando sobre frameworks de pruebas y descubrimos Codeception, que reunía todo lo que necesitábamos en una sola herramienta.

¿Qué es Codeception y cómo podemos instalarlo?

Codeception es un framework de pruebas para PHP cuyo objetivo es crear tests legibles que describan acciones desde la perspectiva del usuario. Nos permite hacer pruebas de aceptación, funcionales y unitarias.

La clave de Codeception son sus actores. Codeception entiende los tests como acciones que ejecuta una persona. Como resumen, un UnitTester ejecuta acciones y testea código, un FunctionalTester prueba la aplicación en su conjunto, y un AcceptanceTester interactúa con la interfaz.

Cada Actor ejecuta Steps, que son instrucciones individuales dentro de un escenario. Las instrucciones que puede generar un Actor se agrupan en módulos: PhpBrowser, WebDriver, DB, FileSystem, etc.

Para su instalación seguimos los pasos descritos en la documentación oficial.

Con la instalación se crea una carpeta llamada tests, y dentro de esta carpeta se crea una estructura básica para codificar los diferentes tipos de pruebas.

Como ejemplo vamos a testear el clásico Login. Aunque son mas los escenarios que detallar en esta prueba solo mostramos alguno de ellos para no extenderlo.

Para crear el test se ejecuta el comando:

php vendor/bin/codecept g:feature acceptance Login

Esto creará una fichero ‘.feature’ en el que escribiremos nuestra historia de usuario en un lenguaje formal llamado Gherkin con la particularidad de que podemos ejecutar estos escenarios como pruebas automatizadas.

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

Los escenarios se escriben paso a paso usando «Given-When-Then».

• La parte GIVEN son las condiciones previas para la pruebas. Desde donde partimos.
• La sección WHEN es ese comportamiento que estás especificando, es decir las acciones que necesitamos.
• Y finalmente THEN que es la parte donde obtenemos el resultado esperado.

Definiendo las pruebas

Nuestro próximo paso será definir y transformar el archivo de características en una prueba válida. Los definiremos en el archivo del AcceptanceTester.

Para conseguir los pasos necesarios se ejecuta el siguiente comando:

php vendor/bin/codecept gherkin:snippets acceptance

Para implementarlos como estamos en la suite de aceptación usamos WebDriver como modulo, ya que nos permite la interacción con el navegador. Esto significa que podemos utilizar sus métodos dentro del archivo Tester, como hacemos con las pruebas de escritura usando

$I->

Se puede emplear diferentes métodos que ya están desarrollados (por ejemplo amOnPage o click). Cada paso del escenario Gherkin se extenderá con los métodos definidos en Codeception.

Vamos a mostrar cómo puede ser implementado en nuestro caso:

/**
 * @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,');
}

Finalmente ejecutamos nuestro archivo .feature con el comando

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

para ver que Given/When/Then se amplían con subpasos y muestra el resultado esperado sobre la ejecucion.

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)

Son muchas las ventajas que nos ofrece esta herramienta, además también cuenta con una aplicación, conocida como Webception, en la que el cliente puede ejecutar todos los test desde el navegador y así poder seguir el estado de su aplicación.

The post Introducción a las pruebas automatizadas con Codeception en proyectos PHP appeared first on WATA Factory.

Para entrar en materia debemos plantearnos las siguientes preguntas: (1) ¿Qué entendemos como proyecto Legacy? (2) Si funciona, ¿para qué tocarlo? (3) ¿Cómo podemos hacerlo? ¡Veamos!

¿Qué entendemos como proyecto Legacy?

Para nosotros, un código Legacy (o código espagueti), es aquél donde no se aplica lo que consideramos buenas prácticas de desarrollo (Clean Code), no sigue los principios SOLID y no cuenta con una buena cobertura de tests (o directamente, ni siquiera los tiene).

Normalmente este código es un código antiguo con varios años en producción (y más o menos fiabilidad), desarrollado sin framework, o en su defecto, utilizando alguna versión antigua de alguno (por ejemplo, Symfony 2).

Si funciona, ¿para qué tocarlo?

Ésta es una muy buena pregunta, sobre todo porque en nuestro gremio se escucha mucho la expresión (a veces, demasiado) Lo que funciona, no se toca.

La respuesta a esta pregunta no es sencilla. Deberíamos plantearnos la modernización (o no) según sostenibilidad y coherencia con las prácticas que se realizan a diario en la compañía.

• Sostenibilidad porque si estamos hablando de un proyecto vivo, cada vez que se hace un evolutivo nuevo, lo único que conseguimos es seguir alimentando al monstruo. Llegará un momento en el que esa modernización de la que hablamos sea prácticamente imposible sin invertir una gran cantidad de tiempo, y por lo tanto, también de dinero.

• Coherencia porque si los nuevos proyectos siguen una serie de estándares de calidad, se realizan tests unitarios o de integración, etc., ¿por qué vamos a tener proyectos vivos, donde no se apliquen estas prácticas por el mero hecho de ser un proyecto ya de largo recorrido?

¿Cómo lo hacemos?

Si hemos llegado a este punto es porque estamos convencidos de querer renovar nuestro código.

En WATA Factory trabajamos con Symfony, así que en nuestro caso, crearemos un proyecto sobre dicho framework e integraremos el código Legacy en él.

Conforme vayamos realizando nuevas funcionalidades, las iremos desarrollando dentro del proyecto Symfony. Las antiguas funcionalidades estarán dentro de lo que llamaremos LegacyBundle. Llevamos a cabo este proceso siguiendo los pasos mostrados en esta guía publicada por Yannick de Lange.

Este Bundle contendrá todo el proyecto Legacy, y mediante el routing iremos redirigiendo nuestros nuevos endpoints al código antiguo para que todo continúe funcionando.

Esta estructura nos da la opción de no tener que migrar todo el proyecto de una vez, con el tiempo y riesgo que ello conlleva. Debemos tener en cuenta a la hora de modificar funcionalidades existentes, sacarlas de la parte Legacy e introducirlas en la nueva. Esto provocará que, con el paso del tiempo, la parte Legacy se vaya haciendo cada vez más pequeña.

Si por alguna circunstancia no utilizamos Symfony, y no pueden convivir juntos el código Legacy y el código nuevo, recomendamos seguir la guía que se nos proporciona en el libro Modernizing Legacy Applications in PHP, de Paul M. Jones.

Paul M. nos proporciona pautas para ir modernizando el proyecto, incluyendo autoload, refactorizando el código, etc.

The post Modernización de proyectos legacy en PHP a través de Symfony appeared first on WATA Factory.