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

# What are services?

Services are the classes containing **domain and application logic**. Every service provides an API to trigger some actions, be it something small like formatting data or something big like creating orders.

Services are also notable because they don’t care what calls them. Each service encapsulates an operation that can be run by a controller, console command, test, or another service.

# How to make good services

We want to make good services. But, to achieve this, we first need to understand what a good service means. A good service is:

+ Easy to use.
+ Easy to test.
+ Easy to modify when requirements change.


Another distinctive feature of good service is **predictability**. We should be able to tell what a service does just by looking at its external API and without knowing how the service works inside.

It should be **true predictability**. Sometimes the service API looks simple but doesn’t show the whole picture. The service might also do something else or work only in specific cases. For example, when we call a service to format a string, we’ll be unpleasantly surprised if we later find out that it works only on Fridays and also wipes the database. The primary goal of structuring code is to reduce the number of things we have to remember, so we should avoid false predictability.


Here are some things that can improve our services.

## Follow SOLID principles

The first and foremost method is to remember and follow the SOLID principles. Make the granular services that implement granular interfaces and follow their intended logic. Make them depend on interfaces instead of implementations, and make them extensible via configuration. 

## Use Dependency Injection

If a service depends on other services, it has to **accept dependencies** as input in the constructor. This lets us influence the behavior of the service from outside. For example, we might want different dependencies for the service in production and testing. Dependency injections also help us reuse the existing service classes.

## Avoid state

The only state stored in the service should be an **immutable configuration** accepted in the constructor. All the input information should be in the method input arguments.

Any non-configuration state in the service will lead to **temporal dependencies** between service methods. These are nasty surprises, like when the method doesn’t work as expected because we forgot to call another method before it. Things like that are hard to document and use.

The most prominent form of state in the services is when we have to initialize the service before using it. Let’s imagine a `CSVExporter` with this implementation:1

Learn the principles you can follow to make service classes better.

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

Service Classes

What are services?

How to make good services