Explore creating scalable PHP web applications, structuring code efficiently, managing data storage, and implementing automated testing to ensure robustness and maintainability in real-world projects.

docker.tar.gz

Serve /usercode

Run index.php (quiet composer install)

Serve /usercode (quiet composer install)

execute_apcu

This course is for people who have already learned the basics of PHP (or just finished the "Learn PHP from Scratch" course) and want the bigger picture of making big web applications with this language.

First, you'll learn how all PHP web applications communicate with the world and how to turn multiple source code files into one application. Then you'll learn multiple approaches to structuring the whole application. It will help you write code that's easy to maintain. Also, this is a common topic for job interview questions.

Next, you'll learn different data storage methods, from user sessions to databases. This course doesn't duplicate the official documentation but instead provides an overview of the various tools you can use. You'll learn how to use them in PHP, their tradeoffs, and how to pick what's best for your project.

Finally, you'll learn how to make automated tests for your project to ensure that it works as expected.

Developing Web Applications with PHP

A set of principles of object-oriented design

It's impossible to do anything without it.

To optimize HTTP packet latency between the client and server.


To let the HTTP server call a single PHP file for all requests.


In MVC architecture, where does **application logic** belong?

In MVC architecture, where does application logic belong?

In MVC architecture, where do **HTML templates** belong?

In MVC architecture, where do HTML templates belong?

In MVC architecture, which layers can depend on **Model**?

In MVC architecture, which layers can depend on Model?

In MVC architecture, which layers can depend on **View**?

In MVC architecture, which layers can depend on View?

In MVC architecture, which layers can depend on **Controller**?

In MVC architecture, which layers can depend on Controller?

A class should have a single public method.

A class should have only one reason to change.


Single people are responsible for everything.


For each class, there should be a single responsible person.


What is the meaning of the **single responsibility principle**?

What is the meaning of the single responsibility principle?

The class has both application and infrastructure logic.

The class has two or more public methods.


The class has logic for different use cases.


Different entities are managed in a single class.


What are the signals that we might be violating the **Single responsibility principle**?


What are the signals that we might be violating the Single responsibility principle?

Objects or entities should be open for extension but closed for modification.


It’s airlock logic. If one door is open, another must be closed.


Objects or entities should be open for modification but closed for extension.


What is the meaning of the **open-closed principle**?


What is the meaning of the open-closed principle?

You have to modify the class to fix a bug.


You have to modify the interface to add another use case.


The class has a `switch` statement for use case-selection.


You have to modify the class to add another use case.


What are the signals that you might be violating the **open-closed principle**?


What are the signals that you might be violating the open-closed principle?

There should be a substitution for every class to create redundancy.


Derived classes must be substitutable for their base classes.


You should be able to substitute every interface.


You must design objects like you're substituting behaviors for methods.


What is **Liskov substitution principle**?


What is Liskov substitution principle?

Implementation can handle only a subset of input values supported by the interface.

Some implementations of the interface cause errors in the code using it.

The child class returns some values that parent class could never return.

A class implements more interfaces than others.


What are the signals that you might be violating the **Liskov substitution principle**?


What are the signals that you might be violating the Liskov substitution principle?

Segregate interfaces from implementations by storing them in another module.


Segregate interfaces from implementations by storing them in another namespace.


Make fine-grained interfaces that are implementation-specific.


Make fine-grained interfaces that are client-specific.


What is the meaning of the **interface segregation principle**?


What is the meaning of the interface segregation principle?

You have interface implementations in which some methods can never be called.


Many clients use only a subset of the interface's methods.

You created the interface by copy-pasting the public method definitions of a class.


What are the signals that you might be violating the **interface segregation principle**?


What are the signals that you might be violating the interface segregation principle?

Depend on abstractions, not on concretions.


To avoid depending on others, make them depend on you.


Depend on concretions, not on abstractions.


What is the meaning of the **dependency inversion principle**?


What is the meaning of the dependency inversion principle?

A class constructs an instance of dependency during initialization.

A class depends on a concrete implementation of an interface.


What are the signals that you might be violating the **Dependency inversion principle**?


What are the signals that you might be violating the Dependency inversion principle?

Introduction

Communicating with the Client

Static Web Application

Structuring Code Files

Application Architecture Basics

PHP-Based Web Application

Storing State

Databases

Using a Database in the PHP Application

Testing

Testing the PHP Application

Advanced Architecture Patterns

Final Assessment

Conclusion

Quiz: Application Architecture Basics