You'll need to install the different PHP versions and make sure modules and config matches up.
If you already have php7.4 installed and you're looking to install 8.3 you could add 8.3 in while leaving 7.4 by installing it by version number with your OS package manager, e.g. with apt on Ubuntu:

sudo apt install php8.3-{cli,fpm}  

However, before installing the new version, you'll need to make sure your PHP pools don't reference a central/single sock file as installing the new fpm may auto switch it to the new version. E.g.

sudo vim /etc/php/7.4/fpm/pool.d/www.conf  

Check if it references /var/run/php/php-fpm.sock and update it to the version it's on like /var/run/php/php7.4-fpm.sock.
You'll then also need to make this update in your nginx or apache file and reload php-fpm first, then nginx or apache.

Once you've installed your new PHP versions, check both php fpm versions are running with:

systemctl status php7.4-fpm  
systemctl status php8.3-fpm  

To help compare config files you could use a tool like meld, vimdiff or diff, e.g.:

sudo meld /etc/php/7.4/cli/php.ini /etc/php/8.3/cli/php.ini  

Make sure to compare both the cli and fpm config files.

Also to help compare PHP modules you can use meld, vimdiff or diff again like so:

meld <(php7.4 -m) <(php8.3 -m)  

Then install missing ones, for example if you spot gd, gmp, intl, xml, curl and bcmath missing you could install them with:

sudo apt install php8.3-{gd,gmp,intl,xml,curl,bcmath}  

Then compare the modules again.

Using PHP FPM you can switch PHP version easily by switching which /var/run/php/php7.4-fpm.sock (this may also be /run/php/php7.4-fpm.sock) you reference in either the Apache or Nginx config (or whichever system you use to host.

E.g. in Nginx it's this line:

fastcgi_pass unix:/var/run/php7.4-fpm.sock  

Or Apache:

SetHandler "proxy:unix:/run/php/php7.4-fpm.sock|fcgi://localhost"  

Your line here may be a little different, the above assumes it's the default version number based sock files but there are alternatives.
Here's 3 additional examples you may find:

• A single /var/run/php-fpm.sock instead of specific version. If that's the case, it will likely be that your php fpm pool for that version points to that single sock file. Your pool will be configured by a file in /etc/php/VERSION/fpm/pool.d/ e.g. /etc/php/7.4/fpm/pool.d/www.conf
  You can either, leave the current one pointing here and make sure your new PHP version has the specific version number in the sock file name and update the reference to it in the nginx/apache config. Or, you could swap which php version uses that sock file by editing the current one to have the version in the file name and the new one to this main sock file. Then restart both versions of PHP FPM.

• Multiple pools, one per site. If you have multiple sites on the server you may have created a php pool for each of them to isolate them. If so, you'll need to copy over these configs to the new version (or at least the ones you want on the new version, maybe test with one first) so if it was /etc/php/7.4/fpm/pool.d/site.com.conf and you're switching to php8.3 then copy to /etc/php/8.3/fpm/pool.d/site.com.conf
SetHandler "proxy:unix:/run/php/php7.4-fpm-site.com.sock|fcgi://localhost" and update the version number in the sock file if it had one, or add one in so it doesn't clash with the other.

• Listing to a port instead of a sock file. listen = 127.0.0.1:7401 In this example you have ports instead of files but they can be updated mostly the same as the sock files. You'll just need to remember or note down which ports relate to which versions & update your nginx/apache configs as needed.

Remember to reload nginx/apache after editing the configs and if you updated your php-fpm configs or pools, reload php-fpm for the versions you updated.

Then for the CLI you can switch with:

sudo update-alternatives --set php /usr/bin/php8.3  

You may also want to switch the php version phar files use as well, you can do this with by running both the following commands:

sudo update-alternatives --set phar /usr/bin/phar8.3  
sudo update-alternatives --set phar.phar /usr/bin/phar.phar8.3  

To make this easier, I added a bash function so I can call php-version 7.4 or php-version 8.3 to switch between them, and call php-version to have it list the php-versions I have available:

# switch php version for CLI
function php-version {  
    if [[ "$1" == "" ]]; then
        echo "Available versions:"
        currentVersion=$(php -v | grep -oP '(?<=PHP )\d+.\d+')
        availableVersions=$(ls /usr/bin/php* | grep -oP '(?<=/php)(\d+\.\d+)')
        echo $availableVersions | sed "s/$currentVersion/$currentVersion *current/"
        echo "Set default for cli with: php-version $currentVersion"
    else
        echo "Setting default php cli version to $1"
        sudo update-alternatives --set php /usr/bin/php$1
        sudo update-alternatives --set phar /usr/bin/phar$1
        sudo update-alternatives --set phar.phar /usr/bin/phar.phar$1
        echo "php -v:"
        php -v
    fi
}

Side note, you can also use sudo update-alternatives --config php to have it interactively show you php versions available and switch that way.

You may ask, why not just run the commands separately, which obviously works, but you need to remember all those commands and the order of which you run them, or write them in a README or similar. Instead, Makefiles offer a simple way to build repeatable commands for a single or series of other commands in a way that you can quickly run when you come to a project. Especially useful when you have new people take over a project, or when you yourself come back to a project a few months or so later.

You use them via the terminal / command line like so:

cd ~/projects/my-project  
make do-something-cool  

Where do-something-cool is the command you want to run in the file.

Many people use Makefiles in different ways, I often don't use many of the more complex features Makefiles have and a number of the tutorials start with a steep learning curve using them.
Instead I'll show you a simple example file from a real project I have.

In this example, I have a project where I need to build / minify some javascript and css for performance. I want to run a linter over some files to be sure the sytnax is a-ok, and then I have written some tests for the code and need to be able to run them quickly after i make changes.

Here's an example of this in a Makefile file.

build:  
    jsmin js/app.js > js/app.min.js
    cssmin < css/app.css > css/app.min.css

test: lint unit-test

lint:  
    find . -name \*.php | xargs -L1 -P4 php -l

unit-test:  
    phpunit .

If you copy this code, make sure you use tabs instead of spaces as Makefiles require them.

Let's break down the above.

1. make build runs 2 commands, jsmin and cssmin. These are npm modules i have installed globally. They minify my js and css code.
2. make test runs 2 other commands but these are other make commands. First it runs lint (which could separately be run as make lint, this checks the syntax of my php files for the project, using find to find all the php files, piped to xargs which then allows me to run php -l for each file. Then it runs unit-test, again this could be run on it's own as make unit-test which runs my phpunit tests. But having a single make test command allows me to run both with ease.

There's plenty more resources out there for learning more about Makefile's, but hopefully this will show how simple and useful they can be.

It's pre installed on Linux & Mac OSX, and on windows you'll need to download something like MinGW to get it installed.

Ditto.php composer package to quickly build a web proxy which replaces my old project under this name.

Usage example:

composer require stilliard/ditto.php dev-master  

Much more information can be found on it's Github repo

Twig a great language for templating, with filters and the ability to extend blocks of other templates it works perfectly for our development flow.

It's easy enough to download with composer and get started with it, but I think I've been spoiled by alot of langauges with REPLs / interactive shells.
So i build a little web interface that allows me to enter some test variables (via JSON), multiple files (to test out includes and extending) and a fast way to render the results.

It's called Twig playground:
http://twig.stapps.io/

Plus it's open source:
https://github.com/stilliard/twig-playground

It's not perfect, but it works for now.

(To edit file names btw, just double click on the name, you can then also delete the file)

Give me an example:

Ok, try it out creating the following 4 files as a simple demo:

index.html.twig:

{% extends "layout.html.twig" %}

{% block main %}
<h1>{{ text | title }}</h1>  
<ul>  
{% for item in items %}
    <li>{{ item.name }}</li>
{% endfor %}
</ul>  
{% endblock %}

layout.html.twig:

<!DOCTYPE html>  
<html>  
<head>  
<meta charset="utf-8">  
<title>Demo</title>  
</head>  
<body>

<header>{% include 'header.html.twig' %}</header>

<div class="main">  
{% block main %}{% endblock %}
</div>

<footer>{% include 'footer.html.twig' %}</footer>

</body>  
</html>  

header.html.twig:

... header ...

footer.html.twig:

... footer ...

It also supports css output, just rename the first file as .css.twig

E.g. Try the following in the playground:

JSON variables:

{ "header_color": "blue" }

index.css.twig:

{% include 'base.css' %}

.body { background: {{ header_color }}; }

base.css:

body { font: 13px/1.4 sans-serif; }  
.header { ...}
.footer { ... }

I simply want a Parser for literally input and output, thats taking in an array, a string or a file, and outputting a string, an array or file(s), and a CSV object to work with the data and have some helpers for mapping over the data columns or rows, adding/removing/sorting rows, that sort of thing.
Hell, most the time I'll probably just want the Parser, as in take this CSV file, and give me an array, or the reverse, but its useful to have that CSV object there for when i need it.

Anyway, that's what I've built, its a composer package up on packagist and github:
https://github.com/stilliard/CsvParser

Install

composer require stilliard/csvparser dev-master  

Example usage

$array = [['id'=>1, 'name'=>'Bob'],['id'=>2, 'name'=>'Bill']];
$parser = new \CsvParser\Parser();
$csv = $parser->fromArray($array);
var_dump($parser->toString($csv));  

So the workflow here is just create a parser, feed in the input and that gives you a CSV object, then you can either do some with with that or pass back over the the parser for the output.

View live on GitHub: https://github.com/stilliard/blmreader

Unlike the other lib's out there, this is pretty bare bones, it doesn't try to offer predefined values and other such helpers, it simple takes in a file and outputs an array. This is pretty handy not only for rightmove files, but for people using rightmove's format but not actually using the same fields, or for when fields get added in the future you wont have to do any work as this way it will automatically allow you access to them :)

Install

composer require stilliard/blmreader dev-master  

Example usage

$blm = new \BLM\Reader(dirname(__FILE__) . '/test.blm');
var_dump($blm->toArray());