Cache Merrill, Founder, Zibtek

Authored By

This interview is with Cache Merrill, Founder at Zibtek.

Cache Merrill, Founder, Zibtek

Welcome to, Cache! Could you tell our readers a bit about yourself and your journey to becoming a PHP expert?

Hello readers! I'm thrilled to share my journey into the world of PHP with you all. My path to becoming a PHP expert started quite early in my tech career. Initially drawn to web development because of the rapid feedback loop—write code and see immediate results—I began experimenting with various programming languages. PHP stood out because of its wide usage for server-side scripting and its significant role in dynamic web page generation.

Over the years, I dove deeply into PHP's nuances, working on numerous projects that ranged from small websites to complex web applications. This hands-on experience was crucial, as it allowed me to understand not just the syntax of PHP but also the best practices, design patterns, and how to effectively structure code for maintainability and scalability.

I also made it a point to stay updated with the PHP community. PHP, like any technology, evolves constantly, and engaging with the community through forums, contributing to open-source projects, and attending conferences helped me stay on top of the latest developments and features introduced in new PHP versions.

Today, as a PHP expert, I focus not only on coding but also on mentoring others, advocating for best practices like TDD (Test-Driven Development), and exploring how to integrate PHP with other technologies to create robust, efficient, and secure applications. It's been a rewarding journey, and I look forward to continuing to grow and help others in the PHP community.

What were some of the key milestones or projects that solidified your expertise in PHP?

Several key milestones and projects have been instrumental in solidifying my expertise in PHP over the years. Here are a few highlights:

First Major Web Application: One of the earliest milestones in my PHP journey was leading the development of a comprehensive e-commerce platform. This project was a deep dive into PHP's capabilities, involving complex user interactions, payment integrations, and inventory management. The challenges of ensuring security and efficiency in transactions and data handling taught me a great deal about best practices in PHP development.

Contributions to Open Source: As I gained more experience, I started contributing to open-source PHP projects. This not only helped me improve my coding skills but also gave me insights into the collaborative and ever-evolving nature of software development. Working on open-source projects allowed me to engage with other developers globally, which was crucial in expanding my understanding and approach to problem-solving in PHP.

Adoption of Modern PHP Frameworks: Another significant milestone was my transition from using PHP in a procedural programming style to adopting modern MVC frameworks like Laravel and Symfony. Learning to use these frameworks effectively for building applications that are scalable, secure, and maintainable marked a significant advancement in my PHP career. It opened up opportunities to work on more sophisticated projects and leverage built-in features for faster development cycles.

Building a CMS from Scratch: Designing and developing a custom content management system (CMS) for a large corporate client was a pivotal project. This experience required a deep understanding of PHP at its core, as I had to ensure the CMS was not only flexible and user-friendly but also robust enough to handle large volumes of traffic and data. It was a rigorous test of my skills in PHP architecture, security, and performance optimization.

Teaching and Mentoring: Finally, teaching PHP to junior developers and mentoring colleagues have been crucial in refining my expertise. The process of explaining complex concepts, debugging issues together, and reviewing code enhanced my technical skills and also improved my ability to communicate complex ideas clearly.

These experiences have shaped my career and expertise in PHP, making each project not just a job but a learning opportunity. They have reinforced the importance of continual learning and adaptation in the field of technology.

PHP has been around for a while now. What are some of the biggest changes you've witnessed in the PHP landscape throughout your career?

Over the years, PHP has undergone significant transformations that have reshaped its landscape dramatically. Here are some of the biggest changes I've witnessed in PHP throughout my career:

Performance Improvements: One of the most notable changes has been the improvement in performance, particularly with the release of PHP 7. This version introduced a new Zend Engine (version 3.0), which significantly increased the speed and reduced memory consumption compared to PHP 5.x. This leap in performance made PHP much more competitive with other server-side languages and gave new life to applications that were becoming sluggish under heavier loads.

Introduction of Modern Frameworks: The emergence and maturation of frameworks like Laravel, Symfony, and Zend Framework have greatly influenced PHP development practices. These frameworks offer extensive libraries, modules, and tools that standardize and streamline the development process, enforce architectural best practices, and bolster security measures. They have also fostered a stronger community around PHP, with vast resources for learning and collaboration.

Composer and Dependency Management: The introduction of Composer, a dependency management tool for PHP, marked a significant shift in how PHP packages are managed and integrated into projects. Composer has simplified the process of managing third-party libraries, ensuring version control and dependency resolution are handled efficiently. This tool has become indispensable for modern PHP development.

Improved Support for Object-Oriented Programming (OOP): Over the years, PHP has significantly enhanced its object-oriented programming capabilities, starting with PHP 5, which introduced private and protected member variables and full support for classes and objects. Subsequent releases have continued to strengthen PHP’s OOP features, including namespaces, late static bindings, traits, and more, allowing developers to write more modular and reusable code.

Stronger Type System: PHP has traditionally been known for its loose typing. However, recent versions have introduced more robust type declarations, including return type declarations and scalar type hints. These features help prevent bugs and make the codebase easier to understand and maintain.

PSR Standards: The PHP-FIG (Framework Interop Group) has developed a series of PHP Standard Recommendations (PSRs), which are standards that aim to ensure a high level of interoperability between shared PHP code. The adoption of PSRs has helped unify coding styles and standards across different PHP projects and frameworks, making it easier for developers to collaborate effectively.

Security Enhancements: Earlier versions of PHP were often criticized for security vulnerabilities. Over time, there have been concerted efforts to enhance the security features of PHP, addressing common security concerns directly within the core and through secure-by-default practices. This ongoing focus on security has helped PHP maintain its relevance in a landscape where security is more important than ever.

These changes reflect PHP's evolution from a simple scripting language to a powerful, robust platform for developing complex web applications. They also highlight the PHP community's commitment to continuous improvement and adaptation, ensuring PHP remains a viable and modern option for web development.

With those changes in mind, what are some common misconceptions about PHP that you often encounter, and how would you address them?

PHP, despite its widespread use and robust development over the years, still faces several misconceptions. Some of these stem from its earlier versions, while others are simply due to a lack of awareness of how the language and its ecosystem have evolved. Here are some common misconceptions about PHP and my responses to them:

PHP is Only for Small Websites:

Misconception: PHP is often thought of as only suitable for small, simple websites.

Reality: PHP is incredibly scalable and powers some of the largest platforms on the web, including Facebook (through a derivative called Hack), Wikipedia, and many others. Frameworks like Laravel and Symfony enable PHP to handle complex, high-traffic applications efficiently.

PHP is Not Secure:

Misconception: Due to its history of security vulnerabilities, some believe PHP is inherently insecure.

Reality: PHP, like any other programming language, can be secure if used properly. The core language has significantly improved its security features and practices. Additionally, many modern frameworks provide built-in security measures that protect against common vulnerabilities like SQL injection and cross-site scripting (XSS).

PHP is Slow:

Misconception: There's a lingering perception that PHP is slower compared to other modern languages.

Reality: The release of PHP 7.x significantly boosted performance, bringing it on par with many other backend languages. The Just-In-Time (JIT) compilation introduced in PHP 8 further enhances performance, particularly for computationally intensive operations.

PHP Does Not Support Modern Programming Practices:

Misconception: Some believe PHP does not support practices like object-oriented programming (OOP) or functional programming (FP).

Reality: PHP has full support for OOP, and it has been continuously improved since PHP 5. It also supports many functional programming concepts. Modern PHP versions and frameworks encourage the use of OOP, design patterns, and composer-based dependency management, aligning with best practices in software development.

PHP's Community is Dying:

Misconception: As newer programming languages emerge, there’s a notion that the PHP community is dwindling.

Reality: The PHP community is very active, with ongoing development of PHP core, various frameworks, and packages. The language's use in content management systems like WordPress also ensures a steady demand for PHP developers.

To address these misconceptions, it's important to highlight the evolution of PHP over the years—its improvements in performance, security, and versatility. Sharing case studies of successful large-scale PHP projects, discussing the vibrant ecosystem of PHP frameworks, and referencing the active community and its contributions can help reshape the narrative around PHP. Ultimately, like any technology, the effectiveness of PHP depends on how well it's used, and with the right practices, it remains a top choice for many developers around the world.

For IT professionals looking to learn PHP or deepen their existing knowledge, what resources or learning paths would you recommend?

For IT professionals interested in learning PHP or enhancing their existing PHP skills, there are numerous resources available that cater to different levels of expertise—from beginners to advanced developers. Here's a structured learning path along with recommended resources to help you effectively learn and master PHP:

Beginner Level

Online Courses:

Codecademy or Khan Academy offer interactive PHP courses for beginners that cover the basics of syntax, control structures, and functions.

Udemy and Coursera provide introductory courses that might also include basic web development principles along with PHP.


"Learning PHP, MySQL & JavaScript" by Robin Nixon - A great resource that covers not just PHP but also the use of MySQL and JavaScript with PHP.

"PHP & MySQL: Novice to Ninja" by Tom Butler and Kevin Yank - This book is updated regularly and provides a comprehensive introduction to PHP and database interactions.

Practice Platforms:

PHPFiddle or offer online environments where you can write PHP code and see its execution without needing a local setup.

Intermediate Level


Start learning at least one PHP framework. Laravel and Symfony are highly recommended due to their popularity, features, and extensive communities.

Laracasts is specifically useful for Laravel learning, offering a wide range of tutorials from beginner to advanced levels.

Build Projects:

Engage in small projects like building a blog, a simple e-commerce site, or a personal portfolio using PHP. This practical experience will solidify your understanding and provide hands-on problem-solving skills.

Books and Advanced Courses:

"Modern PHP: New Features and Good Practices" by Josh Lockhart offers insights into PHP's newer features and best practices.

Advanced courses on Pluralsight or LinkedIn Learning that focus on specific aspects like security, testing, or advanced OOP in PHP.

Advanced Level

Contribute to Open Source:

Get involved in PHP open source projects on GitHub. Contributing to projects like PHPMyAdmin or even PHP itself can greatly enhance your skills and visibility in the community.

Specialized Books and Resources:

"Mastering PHP Design Patterns" by Junade Ali will advance your understanding of design patterns in PHP.

"Securing PHP Apps" by Ben Edmunds provides a deep dive into securing your PHP applications.

Join PHP Communities:

Participate in PHP communities on Reddit, Stack Overflow, or specific PHP-related forums. Attending PHP conferences or meetups can also be invaluable.

Continuous Learning is an essential resource. It not only provides the official documentation but also various tutorials and recent updates in PHP.

Regularly read PHP blogs and podcasts such as PHP Architect, Voices of the ElePHPant, and PHP Internals News for the latest discussions, innovations, and updates in the PHP ecosystem.

By following this structured approach and utilizing the suggested resources, IT professionals can not only learn PHP effectively but also stay updated with the latest trends and best practices in the PHP community.

From your experience, what are some essential best practices for writing clean, efficient, and maintainable PHP code?

Writing clean, efficient, and maintainable PHP code is fundamental to successful project development and long-term scalability. Here are some essential best practices I've found invaluable over my career with PHP:

1. Follow PHP Standards Recommendations (PSR):

Adopting PSR standards, which are a series of recommendations for PHP coding style and architecture, helps ensure your code is consistent and easy to manage, especially in team environments. For example, PSR-1 and PSR-12 provide guidelines for coding style, while PSR-4 addresses autoloading standards.

2. Use a Framework:

Utilizing a PHP framework like Laravel, Symfony, or Zend can significantly enhance productivity and ensure your code is organized according to industry standards. Frameworks come with built-in functions and structures that help avoid common security pitfalls and streamline database interactions and routing.

3. Implement Object-Oriented Programming (OOP):

Embrace OOP principles such as encapsulation, inheritance, and polymorphism. OOP makes your code more modular, easier to test, and reusable. Utilizing classes and objects also helps in organizing code around real-world concepts.

4. Use Meaningful Names for Variables and Functions:

Choose clear, descriptive names for variables and functions. This practice makes your code self-documenting and much easier to understand. For example, a function name like calculateTotalWeight() is much more informative than calcTotW().

5. Keep Functions Small and Focused:

Each function should do one thing and do it well. If a function is performing multiple operations, consider breaking it into several smaller functions. This makes your code easier to test and debug.

6. Avoid Deep Nesting:

Deeply nested code (many levels of indentation) can be difficult to read and maintain. Try to limit nesting by using early returns or breaking the code into separate functions.

7. Document Your Code:

Use comments and PHPDoc comments liberally to explain the "why" behind complex logic. This documentation is crucial for maintaining the code, especially in a team or when returning to your own code after a significant period.

8. Leverage Composer and Namespaces:

Use Composer for dependency management in your projects. It simplifies the inclusion of third-party libraries and ensures that your project dependencies are well managed. Namespaces help avoid name collisions between code from different libraries and your application.

9. Write Unit Tests:

Regularly write unit tests for your code using tools like PHPUnit. Testing each part of your code ensures it behaves as expected and reduces bugs during integration. It also makes the codebase safer to refactor over time.

10. Security Best Practices:

Always sanitize and validate user inputs to prevent security vulnerabilities such as SQL injection and cross-site scripting (XSS). Use built-in PHP functions and avoid raw SQL queries as much as possible, leveraging ORMs and prepared statements.

11. Profile and Optimize Your Code:

Use profiling tools like Xdebug to find bottlenecks in your code. Optimize code by improving algorithmic complexity and reducing unnecessary database queries.

12. Use Configuration and Environment Files:

Store environment-specific variables (like database credentials) in environment files or configuration files that are not included in the version control system. This enhances both security and flexibility across different deployment environments.

By adhering to these best practices, you can ensure that your PHP code is not only functional but also clean, efficient, and maintainable. This approach not only improves the quality of the software but also enhances collaboration and adaptability in development projects.

Security is paramount in web development. What are some common security pitfalls PHP developers should be aware of, and how can they be mitigated?

Security is indeed a critical aspect of web development, and PHP, like any other web development platform, has its share of potential security pitfalls. Being aware of these vulnerabilities and knowing how to mitigate them is essential for developing secure PHP applications. Here are some of the most common security pitfalls PHP developers face and strategies to mitigate them:

1. SQL Injection

Problem: SQL Injection occurs when an attacker manipulates a SQL query by injecting malicious SQL code through user inputs.

Mitigation: Use prepared statements and parameterized queries with PDO (PHP Data Objects) or MySQLi, which ensure that user inputs are treated as data and not executable code. Avoid constructing SQL queries with raw user inputs.

2. Cross-Site Scripting (XSS)

Problem: XSS attacks involve injecting malicious scripts into web pages viewed by other users, which can lead to stolen cookies, sessions, or personal information.

Mitigation: Always escape user input before outputting it to HTML using functions like htmlspecialchars() or strip_tags(). Use Content Security Policy (CSP) headers to reduce the risk of XSS.

3. Cross-Site Request Forgery (CSRF)

Problem: CSRF attacks trick a user into performing actions they do not intend to on a web application in which they are authenticated.

Mitigation: Implement anti-CSRF tokens in forms that are verified on the server side. Use same-site cookies and ensure that state-changing requests (like form submissions) use POST, not GET requests.

4. Session Hijacking

Problem: Attackers might steal or predict session IDs to impersonate other users.

Mitigation: Use secure, HTTP-only cookies to store session IDs, making them inaccessible to JavaScript. Regenerate session IDs after login. Consider using additional mechanisms like IP checks, although they can introduce usability issues with mobile users.

5. File Upload Vulnerabilities

Problem: Allowing users to upload files without proper restrictions can lead to the execution of malicious scripts.

Mitigation: Restrict file types and implement client-side and server-side validation. Store uploaded files outside of the web root and serve them via a script that checks for proper permissions. Never allow direct access to uploaded files.

6. Remote Code Execution

Problem: If an application evaluates code based on user inputs, it can be exploited to execute arbitrary code.

Mitigation: Avoid using functions that can execute code from user inputs like eval(), system(), exec(), etc., unless absolutely necessary. If needed, rigorously validate the inputs using whitelists.

7. Directory Traversal/Local File Inclusion

Problem: Poor handling of file paths could allow attackers to access or execute files stored outside the intended directories.

Mitigation: Validate user inputs used in file operations against a whitelist of allowed values. Use functions to ensure paths are intended to access only secured directories.

8. SSL/TLS Not Enforced

Problem: Not enforcing HTTPS can expose data to interception or alteration in transit.

Mitigation: Use HTTPS for all interactions and configure your server to redirect all HTTP traffic to HTTPS. Implement HTTP Strict Transport Security (HSTS) to prevent SSL stripping attacks.

9. Insecure Deserialization

Problem: Untrusted data that's deserialized can lead to remote code execution, replay attacks, or injection attacks.

Mitigation: Avoid deserializing data from untrusted sources. If serialization is necessary, ensure it's done safely and consider using integrity checks like cryptographic hashes to detect tampered data.

10. Outdated Software

Problem: Running outdated versions of PHP, libraries, or frameworks can expose known vulnerabilities.

Mitigation: Regularly update all components to the latest versions. Monitor security advisories for the technologies you use.

By addressing these common security pitfalls, PHP developers can significantly enhance the security of their applications. It's also recommended to conduct regular security audits and penetration testing to identify and rectify vulnerabilities.

Looking ahead, what are some exciting trends or emerging technologies within the PHP ecosystem that you're particularly enthusiastic about?

The PHP ecosystem is constantly evolving, with several exciting trends and emerging technologies poised to enhance the capabilities, efficiency, and relevance of PHP in modern web development. Here are a few trends and technologies within the PHP ecosystem that I find particularly promising:

1. Just-In-Time Compilation (JIT)

Introduced in PHP 8, JIT compilation represents a significant advancement in the performance optimization of PHP applications. JIT can potentially accelerate CPU-intensive operations and applications by compiling PHP code into machine code at runtime. While its benefits are more pronounced in specific types of applications (like those with heavy computational tasks), it marks an exciting development in PHP's evolution toward handling more complex, performance-critical applications.

2. Increased Use of Asynchronous Programming

Asynchronous programming in PHP, facilitated by extensions like Swoole and libraries such as ReactPHP, allows developers to perform non-blocking I/O operations. This is particularly useful for creating applications that require high concurrency (handling many connections simultaneously) without launching many threads of execution, which can be resource-intensive. This trend is likely to grow as PHP applications continue to scale and require more efficient ways to handle tasks like HTTP requests, database queries, and file operations.

3. Expansion of Serverless PHP

Serverless computing is transforming how applications are deployed and scaled, and PHP is increasingly becoming a part of this trend. Platforms like AWS Lambda have started supporting PHP, allowing developers to run PHP functions in response to events without provisioning or managing servers. This can lead to cost savings and performance gains for PHP applications, especially those with variable traffic and workloads.

4. Framework Advancements

PHP frameworks like Laravel, Symfony, and others are continuously evolving, incorporating new features that enhance developer productivity, security, and the overall robustness of applications. For example, Laravel's Jetstream provides advanced features for application scaffolding, authentication, and team management out of the box. Such advancements not only save development time but also ensure that PHP applications are built on a solid, secure foundation.

5. Improved Integration with Front-End Technologies

The line between front-end and back-end development is blurring with the rise of full-stack development. PHP's integration with JavaScript frameworks like Vue.js, React, and Angular, through tools like Inertia.js, is an exciting area of growth. This integration enables developers to create more dynamic and responsive user experiences while leveraging PHP's robustness on the server side.

6. Headless and API-First Architectures

The trend towards headless CMS and API-first architectures is influencing the PHP ecosystem. Frameworks and CMSs that support these architectures allow PHP developers to build more flexible and scalable systems. These architectures separate the back end from the front end, making it easier to deploy and scale front-end experiences independently from the back-end logic, which is particularly beneficial for enterprises aiming to deliver content across multiple platforms.

7. Increased Focus on Machine Learning

Integrating machine learning capabilities directly into PHP applications is becoming more accessible thanks to libraries like PHP-ML. This integration allows developers to perform tasks like prediction, classification, and clustering directly within PHP, paving the way for more intelligent, data-driven applications.

These trends not only make PHP more powerful and versatile but also ensure it remains a relevant choice for modern web application development. As these technologies mature and find broader adoption, they will undoubtedly open up new possibilities for PHP developers.

Finally, what advice would you give to aspiring PHP developers just starting their journey in this field?

Embarking on a journey as a PHP developer is an exciting opportunity to engage with a technology that powers a significant portion of the web. Here's some advice for aspiring PHP developers just starting out:

1. Master the Basics

Before diving into advanced topics, ensure you have a strong grasp of PHP basics. Understand the syntax, data types, control structures, functions, and object-oriented programming concepts. Websites like offer comprehensive resources that are essential for beginners.

2. Explore PHP Manual

Familiarize yourself with the PHP Manual on It is an invaluable resource, providing detailed information on PHP's built-in functions and features. This knowledge is crucial when you start building projects.

3. Get Hands-On Experience

Theory is important, but nothing beats hands-on practice. Start with small projects like a personal blog, a simple CRUD (Create, Read, Update, Delete) application, or a contact form. These projects will help you apply what you've learned and understand the practical challenges of PHP programming.

4. Learn from Others

Join PHP communities and forums such as Stack Overflow, Reddit, or PHP communities on Discord and GitHub. Engaging with other developers can provide insights into best practices and emerging trends and also help solve common programming challenges.

5. Understand Security Best Practices

Knowing how to write secure PHP code is crucial. Familiarize yourself with common security vulnerabilities like SQL injections, XSS (Cross-site Scripting), and CSRF (Cross-Site Request Forgery). Learning how to defend against these vulnerabilities will make you a more competent developer.

6. Use a Framework

Once you're comfortable with basic PHP, start learning a PHP framework like Laravel, Symfony, or Zend. Frameworks can greatly increase your productivity and help you write more organized and maintainable code. They also embody many best practices.

7. Keep Learning and Updating Your Skills

PHP and web technologies evolve rapidly. Keep yourself updated by following PHP-related blogs, subscribing to PHP podcasts, and participating in webinars and conferences. Continuous learning is key to staying relevant in the field.

8. Read and Write Code

Read other people's code to see different approaches to problem-solving. Open source PHP projects can be a great resource for this. Also, start contributing to open source if you can; it's a great way to learn and improve your coding skills.

9. Build Your Network

Networking is crucial in the tech industry. Attend PHP meetups, workshops, and conferences to connect with experienced developers and potential employers. These connections can be invaluable for career growth and opportunities.

10. Practice Writing Clean and Efficient Code

Focus on writing clean, readable, and efficient code. This includes proper documentation, using meaningful variable and function names, and following coding standards. Clean code is easier to maintain, debug, and scale.

Starting your career as a PHP developer opens many doors in the web development industry. With dedication, practice, and continuous learning, you can grow from a novice to an expert, contributing to complex projects and innovations in the PHP community.