Right now, I am working on a project. It is not completely using AI, but I am doing lots of magic stuff for coding it, but for any practical purpose, lets asume it is programmed AI.

I have a typical website to CRUD some database (in React, but the technology doesn’t matter here much)

3 pages that load a form component, the component is “smart” to display itself differently if it is called by the page insert, update, or delete.

Example:

Reusing of the form component has the following perks:

• One code fits all
• Less code to write
• Reusability

However, it also limits the flexibility. For example, if we want the form for the “page insert” to be different from the form used for the “page update”.

With AI, those points are not as important because it only means a few extra files and a minute or less of token.

With AI, it's time to rethink how the older paradigms are worth using, or if we need to rethink them.

AI and another new paradigm was originally published in Cook php on Medium, where people are continuing the conversation by highlighting and responding to this story.

Problem

I had to analyze and read 14739 folders using PHP, which took over half an hour and I reduced the time to 96 seconds.

While PHP has some async functionalities, they don’t work in Windows. However, some solutions are still available, such as using CURL calls, exec calls, and COM calls, but, these are based on calling the functionality without getting an answer. What progress does it have? What if the operation failed?

So, one solution is to use JavaScript and PHP in tandem. Why?

• JavaScript could coordinate a visual interface and the async calls.
• While PHP does the job.

Then I created this simple library:

EFTEC/MultiOne: MultiOne is a library to execute concurrent tasks programmed in PHP using JavaScript

How does it work?

It works in 3 stages:

• Starting the jobs and creating the payload for every worker. A worker is the process that does its job.
• Every worker does his job
• And when every worker ends, you can do a final operation.

The code:

First, we create an instance of the class

use Eftec\MultiOne\MultiOne;
$work=MultiOne::Factory(
    1000, // miliseconds
    basename(__FILE__), // the file to call (itself)
    4 // number of workers
);

And we want to call the next 3 functions

Create the initial works (4 workers, 4 jobs). It could be any value and not just arrays.

In this case, every worker will be assigned an array or values.

static function($numWorkers) {
        $work=[
            ["apple","banana","pear","orange","lemon"],
            ["alpha","beta","gamma","delta"],
            ["tango","charlie","foxtrot"],
            [1,2,3,4,5,6,7,8,9,10,11,12],
        ];
        return $work; // we give every worker a work
    }

Second, we do the work. In this case, we pop an element at the end of the array and we display it. If the array is empty, then we send an “end” command (we stop the worker)

static function($idWorker, $payload) {
        usleep(500);
        $current=array_pop($payload); // apple, banana, etc.
        if($current===null) {
            return MultiOne::msgAnswer('end',$payload,$current.' work done');
        }
        return MultiOne::msgAnswer('run',$payload,$current);
    }

And third, when every worker has stopped, we could do a final operation. In this case, we are only returning a simple message.

static function($payloads) {
    return 'work done';
}

We add those 3 functions as follows

$work->setMethods(
    static function($numWorkers) {
        $work=[
            ["apple","banana","pear","orange","lemon"],
            ["alpha","beta","gamma","delta"],
            ["tango","charlie","foxtrot"],
            [1,2,3,4,5,6,7,8,9,10,11,12],
        ];
        return $work; // we give every worker a work
    },
    static function($idWorker, $payload) {
        usleep(500);
        $current=array_pop($payload);
        if($current===null) {
            return MultiOne::msgAnswer('end',$payload,$current.' work done');
        }
        return MultiOne::msgAnswer('run',$payload,$current);
    },
    static function($payloads) {
        return 'work done';
    }
);

Finally, we execute the class

$work->runAuto();

Our entire code will look as follows

$work=MultiOne::Factory(
    1000, // miliseconds
    basename(__FILE__), // the file to call (itself)
    4 // number of workers
);
$work->setMethods(
    static function($numWorkers) {
        $work=[
            ["apple","banana","pear","orange","lemon"],
            ["alpha","beta","gamma","delta"],
            ["tango","charlie","foxtrot"],
            [1,2,3,4,5,6,7,8,9,10,11,12],
        ];
        return $work; // we give every worker a work
    },
    static function($idWorker, $payload) {
        usleep(500);
        $current=array_pop($payload);
        if($current===null) {
            return MultiOne::msgAnswer('end',$payload,$current.' work done');
        }
        return MultiOne::msgAnswer('run',$payload,$current);
    },
    static function($payloads) {
        return 'work done';
    }
);
$work->runAuto();

If we call this PHP file, it will show the next values

It’s simple and it works.

A new version

Code:

$work=MultiOne::Factory(
    1000, // miliseconds
    basename(__FILE__), // the file to call (itself)
    4 // number of workers
);
$work->setMethods(
    static function($numWorkers) {
        $work=[
            [["apple","banana","pear","orange","lemon"],5],
            [["alpha","beta","gamma","delta"],4],
            [["tango","charlie","foxtrot"],3],
            [[1,2,3,4,5,6,7,8,9,10,11,12],12],
        ];
        return $work; // we give every worker a work
    },
    static function($idWorker, $payload) {
        usleep(500);
        $txt=str_repeat('📦',count($payload[0])).str_repeat('✅',$payload[1]-count($payload[0]));
        $current=array_pop($payload[0]);
        if($current===null) {
            return MultiOne::msgAnswer('end',$payload,$txt);
        }
        return MultiOne::msgAnswer('run',$payload,$txt);
    },
    static function($payloads) {
        return 'work done';
    }
);
$work->runAuto();

Running several processes in PHP was originally published in Cook php on Medium, where people are continuing the conversation by highlighting and responding to this story.

What is an ORM?

An ORM is an abstraction of the information of the database. For example, let’s say we have a list of cities and we want to list it.

It is the PHP PDO version:

$stmt = $pdo->prepare("SELECT * FROM cities");
$stmt->execute();
$result = $stmt->get_result();
$cities=[];
while($row = $result->fetch_assoc()) {
  $cities[]=$row; 
}
$stmt->close();

While this code could work but it is prone to mistakes and it could be tedious in the long term. What if we could simplify it and turn more focused into a PHP model? That is the concept of ORM.

And it is the ORM version of it.

$cities=CitiesRepo::toList();

The ORM version is simple but there is more about ORM.

In general, ORM allows abstracting access to the database simplifying it.

ORM is not a solution fits all. I will explain it later.

Sometimes we don’t want to add a whole framework to do this job, this example is about that.

Getting started

For this example, you will need:

• PHP 7.1 or higher.
• PHP must have the PDO and PDOMYSQL extensions installed.
• Composer
• Mysql with the example tables
• For this example, I will use the next database: Sakila-Database-2021
• 1) Create a new project using composer and add our library. (open a terminal, bash, PowerShell, cmd, etc.)

composer init  # and fill the information of your project.
composer require eftec/pdoonerepo

• If the composer fails, then remember to install it and add it to the path.
• 2) Once it is done and the libraries are downloaded, then run the next command

./vendor/pdooneorm

It will show the next screen

And now, you are in interactive mode.

In interactive mode you can:

• select your own option
• if you write “?” then it shows a simple help, that explains what command does what.
• If you write “??” then it shows technical help
• If you press the key tab, then you can autocomplete the options, so you won’t need to write all the options.
• If you press arrow-up or arrow-down then you can navigate in the history (if any).

The first option is it shows [connect] [pending] It is because we aren’t connected to the database.

Write “connect” to enter the connect menu so we could create a new connection (remember that you can use autocomplete, i.e. if you write comple<table> then it will autocomplete the rest)

Then enter the option “configure”.

And configure your database. If you fail, then you can try it again.

• the type of database: “MySQL”
• the server: 127.0.0.1 in my case.
• The user: root
• The password: abc.123 ← that is my password, so please keep it secret (wink wink).

• And the schema: “sakila” (or the schema that you want to use)

Once it is done, it will show:

the [ok] says that we are [ok] with this step. For example, you can save without configuration but it does not make any sense.

And about saving, enter the option “save” and save your configuration because you don’t want to re-enter the entire configuration every time.

It will save the next file: config.config.php

<?php http_response_code(404); die(1); // eftec/CliOne(1.24) configuration file (date gen: 2023-03-11 17:40)?>
{
    "databaseType": "mysql",
    "server": "127.0.0.1",
    "user": "root",
    "pwd": "abc.123",
    "database": "sakila"
}

You can reload the configuration using the option “load” or call as a flag.

But what this file means?

• It is a PHP file that contains a JSON inside.

Lets me explain about security. Let’s say we write this file as config.json and we commit the mistake to avoid locking it, so everybody could read this configuration as mydomain.dom/config.json
Now, since it is a PHP file, then even if it is available directly, then mydomain.dom/config.config.php will return a 404 empty page. So, this file is already safe from prying eyes. How course, it keeps the password in plain sight, so it is not safe if you are exposing your configuration file to others.

It is a really common vulnerability.

About loading the previous configuration, you can load it in interactive mode or you could load it using the command line:

pdooneorm --fileconnect config

You can also save the file as a PHP file. It is the PHP file version

<?php // eftec/CliOne(1.24) PHP configuration file (date gen: 2023-03-11 17:50). DO NOT EDIT THIS FILE 
/**
 * it is the configuration of PdoOne
 */
$pdoOneConfig=[
    'databaseType' => 'mysql',
    'server' => '127.0.0.1',
    'user' => 'root',
    'pwd' => 'abc.123',
    'database' => 'sakila',
];

It is also a safe file and you can expose it to the world and nobody will see its content. This file could be used later to code (or you could simply copy and paste its content).

Creating the repository classes

Once we are connected, we could use the options available in the menu “repo”.

It is the repo menu. It has its own configuration but it also requires a connection.

• Use the “scan” option.

• 1) it will show that it is reading the structure. It is an important part. The library scans for tables and creates a catalog about what tables exist, what structure, relations, etc.
• 2) Once it is done, then it will show [ok]
• For every new change, then you must run this command.

And now, let’s determine the folders. Use the “folder” option.

• Select the relative directory. My example is “repo”.
• Select the postfix of the class. If the class is called City, then the repository class will be called CityRepo.
• The current path (for my example) is
• D:\www\currentproject\PdoOneORM\examples\example2/repo
• For the next step, we will need to configure Composer.
• It is part of my composer.json

• I will try to find a namespace that fits my route. In my case, it is my namespace. i.e:
• folder: D:\www\currentproject\PdoOneORM\examples\
• namespace: eftec\examples
• Since my folder is D:\www\currentproject\PdoOneORM\examples\example2/repo
• then the namespace must be
  eftec\examples\example2\repo
• If you do have not a path in composer, then save your configuration, close the program, then edit composer and re-open the program again.

So, we have configured:

• ✅ connection
• ✅ folder
• ✅scan.

So we could create the code. Use the option “create”

It will populate the repo folder with many files

Mainly there are 3 kinds of files.

• Abstract classes. It will contain the definition of the table, indexes, relations, etc. You should not edit those files because if you “scan” again, it will rebuild this file.
• Repo classes, is the file that you can edit.
• Base class. There is a simple class (in this case called Sakila) that is used for all other classes. It has relations between classes.

Don’t forget to save your configuration.

Using the repo classes.

In the same folder, write the next code: example1.php

<?php
include __DIR__."/../../vendor/autoload.php"; // edit the path for the correct one.
$cities=eftec\examples\example2\repo\CityRepo::toList();
var_dump($cities);

If you run this example, then it will fail because you are not connected to the database.

Do the next modification

<?php
use eftec\PdoOneORM;
use eftec\examples\example2\repo\CityRepo;
include __DIR__."/../../vendor/autoload.php"; // edit the path for the correct one.
$conn= PdoOneORM::factoryFromArray([
    'databaseType' => 'mysql',
    'server' => '127.0.0.1',
    'user' => 'root',
    'pwd' => 'abc.123',
    'database' => 'sakila',
]); // you can include the PHP file generated previously or copy and paste its configuration.
$conn->open(); // opens the database connection. $conn is a singleton, so you don't need to open it every time you want to use.
$conn->logLevel=3; // it is optional,
$cities=CityRepo::toList(); // $conn is injected automatically inside every "Repo" class.
var_dump($cities);

It will show:

But we could do even more. In this case, the table “city” is related to the table “country”.

Edit the line where you list the repo as follows:

$cities=CityRepo::recursive(['/_country_id'])->toList();

The function recursive will try to load this field. How do you know the name of the field? Every field indicated here starts with “/”. If you look at the code of CityRepo, it will show every field:

It says that “_country_id” is a many-to-one relational field. Also “__address” is another relational field (one-to-many)

You can fetch both tables as follow:

$cities=CityRepo::recursive(['/_country_id','/_address'])->toList();

ORM or not.

ORM could make our life easiest but it could have some hidden costs.

• many-to-one relations are “join” in disguise.
• “one-to-many” relations are multiple queries.
• ORM also loads every row and sometimes the internal queries could be long

select address.address_id as `/address_id`,address.address as `/address`,address.address2 as `/address2`,address.district as `/district`,address.city_id as `/city_id`,address.postal_code as `/postal_code`,address.phone as `/phone`,address.last_update as `/last_update` from address where address.`city_id` ='599'

If we want performance or we simply want to show a table, then we could use a native query:

$cities=CityRepo::query('select * from city inner join country on city.country_id=country.country_id');

It will return the next fields:

While the result is similar to the ORM but the structure is different.

Other examples

// inserting
$newCity=['city' => 'new city','country_id' => 105];
CityRepo::insert($newCity);
// updating
$newCity['city']='name changed';
CityRepo::update($newCity);
// deleting
CityRepo::delete($newCity);
// delete by id
CityRepo::deleteById(100);

There are more than +100 features available to use but they are the basic ones.

Costs

Why not a framework?

• This library consists of 11 files
• The complete dependency of this library is 28 files.
• The example consists of 37 files.

So, the whole project example is less than 100 files. It doesn’t all the job as a framework but it is a start.

In comparison, PHPUnit alone has +500 files and a project in Laravel is over +6000 files.

The more files, the slow to deploy, it uses more space, and PHP must deal with more files in the memory (OpCache must retain a catalog with every file). Even “Composer autoload” must have a huge file with all the files.

Also, since it is a simple project, you could even deploy without using Composer, however, you must include the files on your own.

Plus, you can even use it inside a framework.

Why or why not an ORM?

Sometimes we want both cases. For example, for the frontend, we could use native operations because they are fast and we don’t need the whole structure of the ORM, and for the backend, we could use the ORM because it is easy to work with it.

So about ORM, the answer depends, and usually, the solution is both.

Using ORM in PHP without a framework. was originally published in Cook php on Medium, where people are continuing the conversation by highlighting and responding to this story.

I there, I use cloudflare for some of my servers. I tried using the cache system but while it works, it also adds more time to the load of the page (TTFB *) so I didn’t worked for me at least in most websites. But, I still use the DNS service which is available to use without cache. So I use mainly for the DNS and only a few pages uses the cache. Nothing wrong here.

(*) CloudFlare says that the TTFB delay is not a big issue. I think the opposite.

However, recently I found the next problems:

• Cloudflare affects somehow the content of some pages even when you are not caching it. How, and why? I don’t know but Google Bots shows me some nonexistent links that were generated by CloudFlare.
• And now, somebody is using the IP of Cloudflare to probe one of my server.

• The IP is owned by CloudFlare https://www.cloudflare.com/ips-v4
• And my website does not use WordPress in any way and there is no file (or folded) with such name. Also, there is no content or link to that file. I double-checked that.

So, what is going on with CloudFlare?

I don’t think CloudFlare is trying to hack my server and maybe somebody is using CloudFlare as some kind of proxy. But, since I don’t really know what is going on, then that IP of CloudFlare was banned from my system.

In any case, I think it is time to move out of CloudFlare.

Is it for money?

No, most open source projects barely receive any donation. Even top projects could receive less than 100 donors (each one donating around $1-$5 bucks per month). Is it not even enough to pay the time invested.

Is it for the curriculum?

Nope. Interviewers barely care about it.

Is it for the fame?

Haha, no.

So why?

It is for you.

If you have a private library for a project, then when the project is done, then you most likely will abandon the library. When you create a library for a project, you usually are creating a solution that only fits a single needing.

While it could sound practical but if you are developing many projects, then sooner or later you found yourself creating a similar library many time.

Now, if you create an open source project, then you are publishing it and that is the important part. You are exposing a code everybody could look at it and in some cases (rare cases), people could find and solve bugs.

If it is an open source project, then it is easy to share with your team, and the team could share, edit, etc. and they could follow some standard and guideline(*). And thanks to the modern services (github, bitbucket, etc.) then it is way to easy to share an open source project than a close one.

(*) How does it work?. commonly in a private project, nobody care to add documentation, explanation, etc. However, it is not the same with a code that everybody could look at it (not always). For example, we used a project where one of the comment said “He bob, check this code” (ps: bob never checked the code). Close source libraries trend to cut a lot of corners, after all, this code is for one usage.

You could also create a private repository but if you migrate of company, then while you could copy it in a pendrive and bring it to the new company. However, your new team will be less willing to adopt it.

Also, legally if you work for a company developing code, then the close source code is owned by the company. It is not the same with an open source project. Of course, you don’t want to open source strategic code.

i.e.

When you share a project with others, then you also sharing a project with the “you” from the future.

How not to poach a senior developer in easy steps:

• To be unclear with a new proposal of work. Where? conditions? 🚩
• Never mention salary until later in the process. Because the time of a senior developer (that most likely is already working) is worth nothing /s. 🚩
• Start with a “initially you will earn… but later you could earn”. That is a another red flag. 🚩
• Do some online test where the candidate must remember some programming concepts or write a code by hand. I wonder how many seniors developers don’t know how to use Google. 🚩
• And hire some developer as simple programmer with no decisions in the process. So, you are poaching a senior developer that most likely lead a team, and you want to put instead lower in the “food chain”. 🚩
• And I forget, requirements that obviously were written by somebody that is not a developer (and most likely copy and pasted from the newspaper or magazine). 🚩

PS: For some odd reasons, Germany is in a frenzy by hiring developers but, apparently Germany is not hiring developers because they need developers but they need CHEAP developers. Under the current market, companies have the next options:

• cheap
• good

pick one of them.

Any lower than €70,000 euros per year is a shitty job.

Dartis quite similar to C# in several aspects. In fact, it is more like a C# minus all the mumbo jumbo of C#.

For example, you don’t need “public”, “private”, “protected”, etc. Dart doesn’t have it (it has a prefix “_” for private but you are free to use it or not). In general, in Dart, every field is private, you can use setter and getters but it is not the way of Dart.

Second, the management of NULL is top notch and it is better than C#

In C# you could have: SomeClass instance=null;

In Dart, you could not have that variable that stores a null, no matter if it is an object or not. So, we will never ever have null pointers unless we explicit allow it. Dart is what we could call, a safe language.

But in general, if you know C#, then you know Dart.

In short, you can learn Dartin a weekend. The only “weirdness” is Stream and the constructors.

2) I don’t want to learn a new way to write a template

Flutter uses a different approach. It doesn’t use a template language at all. Everything is code. It is a nightmare if you want to use a fancy GUI editor but since practically every GUI editor is horrible (excluding XCode and IOS), then it is not a big deal. JSX, XAML, Blazor etc. are horrible (especially XAML), so you are free from them. Why they are horrible? It is because they are many differences between in what we draw versus in what we finally saw. For example, it is not the same to see an empty list versus a list full of data.

The advantage is the integration between the code and the “template” is seamless, because everything is code. If you learn Dart, you learn “templating Flutter”.

Plus: Flutter was designed and created thinking in Hot Reload, so it is easy to design a widget and see the changes instantly.

3) I don’t want to deal with fluid components

Most flutter Widgets don’t scale visually, and the few ones that scale, mostly use the whole space. You must do it on your own. This means, that we don’t deal with “anchors” or some wacky components that automatically screw our design.

4) And what about State management.

Every widget in flutter has their own fields but you don’t even need fields inside a widget to keep and draw some values.

Flutter works mainly with a simple function: setState() and nothing else much (the other is initState())

Flutter doesn’t work with state directly but with differences in the widgets. If the widget is considered “dirt”, then it draws only the parts that have changed, no matter the states or values. You can even use global variables as “states” or a function. Flutter doesn’t care, it simply works!.

5) I don’t want to learn a new framework

Flutter consists mainly in two kind of classes.

• Stateless Widgets
• Stateful widgets.

And nothing more!.

While Flutter has “states” but they are not the same as other frameworks. The states are just variables (field, global, a function, you name it). So you won’t find a complex flow to manage states such as Redux.

React Redux flow: (it is just one of many flows of react)

It is the flow of a Stateful widget (the green step are a simple function).

And Stateless widgets are the same, minus the setState() and didUpdateConfig().

Developing for Flutter is the same as to develop a pyramid

Why? We usually create code inside code, inside code inside code. We could split it creating widgets but finally everything is inside other thing (excluding the main function).

I finished writing a library for PHP and I found a lot of details about CLI in general.

GitHub - EFTEC/CliOne

But first, what is a CLI and why CLI?

CLI is a program that works in the line command (shell, cmd, PowerShell). Usually, it is considered GUI-less but some CLI also contains GUI. Here, I will talk about a GUI-less interface

If you are creating a code for the average end-user (for example somebody non-programmer), then most likely no, it is not the right tool. The average end-user will prefer something more easy to work with it, with a GUI, maybe a website or an application.

However, if your end-user is a programmer or technician, then it makes a lot of sense to write a CLI instead of building something with a visual interface.

Two ways to work with CLI — Argument

There are two ways to work with CLI, as an argument or as user input.

Example:

program -argument 1 -argument 2

Where you can pass one or multiples arguments to a program.

Pro:

✅ You can chain with other scripts

✅ You can repeat the command many times by copying the execution line. For example, I needed to create 20 virtual machines in Azure and while it is possible to create using the Azure portal (website), it will take a lot of time. Azure allows to run it via a command line, so I write the line to create 1 virtual machine, and I duplicated it 20 times (changing the names of every virtual machine).

✅ You can even do some extra tricks such as input or output values.

Cons:

❌ Security concern, every argument is stored in the history shell, so you don’t want to write a password here.

❌ You don’t want to use more than 10 arguments. Example:

program.exe -argument1 hello -argument2 hello -argument3 hello -argument4 hello -argument5 hello -argument6 hello….

Note: It’s curious but there is not a standard or even good practice to write arguments for a console line program. GNU and POSIX have some kind of standard but it is not completely followed by them, while Microsoft follows different rules. Also, every developer could follow their own rules.

Example:

• “-argument” with a simple “-” at the beginner.
• “ — argument” an argument with a double “-” and the beginner.
• “argument” without any “-” at the beginning of the operation.
• And some tools allow both, one with a short name, and with a long name. Does it help? Not really, it makes it hard to understand some code.

Also, some arguments are written with a “=”

• “-argument=value”
• “-argument value”

And even more. In some programs, arguments are case sensitive, for example

• “-a”
• “-A”

Both arguments could do something completely different.

But even when there is not a standard, it is still usable. Mainly because it is aimed at people to know what they are doing. However, some CLI commands are highly dangerous and accident happens.

Two ways to work with CLI — User Input

There is another way to work: user input or the user enters (manually) the information.

>program.exe

what is the value of the first value? hello ← ✋ user input

Pro:

✅ Security concern.

✅ You can use as many values as you want to.

✅ The user has more interactivity with the tools, including the chance to select values, mark values, enter more than one value, re-try to enter values, etc.

Cons:

❌ You can’t chain with other scripts

❌ You can’t repeat the command by copying the execution line.

In any case, you can use both methods to write your CLI program.

However, why CLI?

There are many advantages to using a CLI:

• It is easy to program. It is easy to create a program with dozen of options by simply adding a few lines of code.
• Some CLI programs are multi-platform by nature, it runs everywhere (Windows, Linux and Mac).
• It doesn’t require a server.
• It uses less bandwidth.
• (as I said), it is possible to add it into another script or chain with other scripts.

Also, there is another advantage:

• It’s safe (for servers).

Why?

Most servers, if not all servers, only allow administrators to access the command line (shell), so the only way to call this program (CLI) is to have access to the server. It is different with a website (for example a backend), where everybody could access it (if it has the access). While a CLI is by default protected by good practices of any good administrator.

Also, it is possible to restrict and allows permission to only system administrators by using a few commands. Example:

sudo mycliprogram

You can leave some script exposed to the world and hackers will not be able to enter the system. Maybe they could get some information (if they could read the script as a file) but nothing more.

But there is another advantage:

• CLI is more straightforward.

Why?

Commonly a GUI could contain many operations and actions in the same screen, such as input text, buttons, combo boxes, etc.

A CLI is way more straightforward, and usually, the user is aimed to do a specific task in a specific order, for example:

1. What is your name? ____
2. What is your age? ____
3. What is your email? ____

While it also limits the options that the user could do but it is also one way (or a few ways) to do something.

It is possible to create a step-by-step (or wizard) using a website, but even when the website could limit the options but the nature of the GUI allows other additionals, such as going back, refreshing, clicking a different link, abandoning the page, etc.

CLI is also more straightforward to install. Sometimes it simply requires to install a single file and nothing more.

Ugly

However, CLI mustn’t be specifically ugly. It must not be too fancy but it could contain colours.

There are some CLI programs that try to mimick the behaviour of the GUI, that even include a mouse, windows, etc.

Experience about Command Line Interface (CLI) was originally published in Cook php on Medium, where people are continuing the conversation by highlighting and responding to this story.

I regret using PHP.

Right now, I finished a titanic project (around 3 year in the making) and the project is working as expected. However, it feels so fragile and I think I loss a lot of time in some other tasks rather than the own code (including testing/benchmarking libraries, creating our own libraries).

One of the key part of the project is the access to the database, so for this, I use an “orm”. For PHP, you can use any ORM in PHP to do the job, however, this project is not easy and it requires some tricks.

First, I tried Laravel and the performance of Laravel (because I want to use its ORM) could be resumed in a single word: SLOW. So I rejected it completely. I tested other ORM and they are also really slow, so I created one from scratch with two goals:

a) simple
b) fast.

And here is the project

https://github.com/eftec/pdoone

And it works (more or less).

Why do I need an ORM?

Because it is not possible to create a project using the primitive functionalities of PHP (PDO in this case), example:

Using PDO
(it is prone to mistakes)

$stmt = $pdo->prepare("SELECT * FROM myTable WHERE name = ?");
$stmt->bindParam(1,$_POST['name'],PDO::PARAM_STR);
$stmt->execute();
$result = $stmt->get_result();
$products=[];
while($row = $result->fetch_assoc()) {
  $product[]=$row; 
}
$stmt->close();

Using my library

$products=$pdoOne
    ->select("*")
    ->from("myTable")
    ->where("name = ?",[$_POST['name']]) 
    ->toList();

Using my library (ORM)

ProductRepo // this class was generated with echo $pdoOne()->generateCodeClass(['Product']);
    ::where("name = ?",[$_POST['name']])
    ::toList();

Then, I found the main problem of PHP: “dynamic typing”.

dynamic typing

Let’s say we have a function that returns a list of products.

$products=ProductRepo::listall();

However, PHP does not know if we are returning a list of products. We could add type hinting, but (as its name says), it is just a type hinting/validation and nothing more. Type hinting is a cheap solution and it is not foolproof at all.

function listall():array {
      // code goes here
   }

But, there is another problem. PHP doesn’t have the concept of array-of-a-specific-type.

It is Java:

products=new ArrayList<Product>();

It is c#

products=new List<Product>();

And it is PHP

$products=array(); // or simply [], so we could store an object, a number or whatever value here.

objects versus array

Let’s say we have a model of an invoice.

class InvoiceDetails {
   public $idInvoiceDetail;
   public $idInvoice;
   public $product;
   public $quantity;
}
class Invoice {
   public $idInvoice;
   public $customer;
   public $date;
   public $invoiceDetails;  // a list of invoicedetails
}

What if we want to serialize:

$invoice=new Invoice(); // $invoice is an instance of Invoice
   $json=json_encode($invoice); // $json is the class serialized
   $invoiceback=json_decode($json); // now $invoice is an instance of stdclass.

We could convert it manually but it takes so much resources to have a correct serialization.

So, the best solution is to use an associative array. Why?

$invoice=['idinvoice'=>1...]; // $invoice is an array
   $json=json_encode($invoice); // $json is the array serialized
   $invoiceback=json_decode($json,true); // now $invoice is an array.

In PHP, we don’t need to use models at all. We could use a bit of them to get some type hinting but again, it is not a perfect solution, neither it is foolproof or help in a big project. It also kills the performance considerably (mainly if you want to serialize/de-serialize).

Are libraries the solution?

There are some libraries to help solving those problems. However, they bring new problems: performance. Many PHP libraries use a lot of “hack” solutions to solve the problems of PHP such as serialization, for example using reflections and such. However, they are a minefield and some of them don’t care about the performance at all.

But why I regret PHP?

Let’s say our initial problem, a function that returns a list of products.

It is PHP

$products=ProductRepo::listAll();
   // show the first product if any
   if($products!==null && count($products)>0) {
      echo $products[0]->name; // or $products[0]['name'] if array
   }

There is not warranty that this code will work because the PHP language does not really know that $products has a list of products.

It is c#

List<Product> products=ProductoRepo.listAll();
   if(products!=null && products.Count()>0) {
      console.log(products[0].name) 
   }

It will always works because c# knows that the variable products is a list of products (or null) and there is not other alternative.

And it is the implementation of the function in c#

function listAll() {
    var result=new List<Product>();
    using(var dbase=new BaseExample()) {
        result=dbase.Products.toList();
    }
    return result;    
}

It simple and it works. There is not minefield here.

It uses Entity Framework and it reads from the database, converts the value and returns a list of products. The performance hit is minimum (I tested). Why? First, the system does not need to guess the field (the field exists or it raises an error), it does not need to do type juggling and because C# is a compiled language.

And it is the serialization/de-serialization

string json = JsonSerializer.Serialize(products);
var productsdes = JsonSerializer.Deserialize<List<Product>>(json);

And again simple and it works or it raises an error (there is not middle ground here).

For the records and about the comments

About Swoole

I tested Swoole and it works. However, it brings two problems:

a) It does not work on Windows.

You can’t whine anything against Windows, but Windows is king for corporate and big companies. It means for example the office suite and other programs such vpn that only works in Windows. My Dev machine is and will be Windows because it works almost all programs (there are 3 exceptions, one of them is Swoole). ps: The second program that does not work in Windows is Docker. There is a version of Docker for Windows but it is a “tiny”-emulator, so it is not a true (lightweight) container but a bulky one (so it breaks the raisons d’être of container)

b) Swoole is not magical. It is not a new PHP runtime engine on steroids, so if PHP is slow then Swoole too. i.e. Swoole works fine in one cases but bad in others. Also, I am not fancy to add more complexity to the code.

And for this case, C# allows async tasks natively, so we don’t need to runs a separate service so we could multi-task those slow task in a separate thread (and without creating sockets). Microsoft warns us about when we should use it and when don’t because multitasking is not a magic wand that works for every case.

Why I use PHP 5.x?

No, I don’t. I use PHP 8.0.10. However, I can keep my code syntactically compatible with PHP 5.6 (at least the open source libraries). There are some new syntaxes in PHP 7 and 8 but most of them are syntax sugar, so it is not worth to migrate those public library from 5.6 to 7 or 8. Why?

However, there are a few useful functions but nothing else much. I like the opcache of PHP >7.0

Type hinting

One of the new features of PHP 7 is the type hinting and it is another minefield.

Why?
In PHP, type hinting is also type validation, and it is validated not once but every time the function is called.

https://github.com/EFTEC/php-benchmarks#type-hinting

// what you write
function example(Class $field1): string {

}
// what php really does:
function example($field1) {
    if(!get_type($gettype)!='Class') {
        throw new Exception("field incorrect");
    }
    // ...    
}

So it affects the performance. It is not a big deal in most of the code but some functions are called not once but thousand of times per request of the user. For example, if we have a function that takes 0.001 seconds but this function is called 100 times, then, in total it takes 0.1 second, so it is not so bad, but this measure is per request, so if we have 100 concurrent request, then we are taking 10 seconds in total. If we split in 4 cores, then each core is taking 2 seconds and it is not good.

Luckily, type hinting adds a mere 0.0001 seconds per 5000 requests, however it’s easy to pile up slowness (example, 1000 concurrent users listing 5000 rows and each row calls 1 function)

I heavily use PHPDOC that it doesn’t impact the performance and it is still more powerful than type hinting. It is not ideal but it is give some balance between performance and hinting.

Python in this aspect is more straightforward, In Python, type hinting is only that, a hint, not a validation, so its up to the code to validate the code.

C#: it does not need any of them because the validation is done at compile it, so it is evaluated once, versus PHP that it is evaluated for each call.

Psalm and PHPStan.

Both are nice libraries but again, they are not for free (they add a new “compile stage”). However, they don’t do magic either, they are unable to detect all if not common problems while it forces us to work (for some tasks) in some very precise task.
But, I skip them because PHPStorm does many of the tasks of both without slowing the development process.

But again, both libraries are not even able to determine the right type of field of a variable (if the variable is enough complex).

About C#. C# has some libraries that do the same job. However, Visual Studio (not code) also do a superb detecting problems right out of the bat, but it also allows refactoring.

In general.

PHP is not a bad language. If you look at Python and Django (or Ruby and Rails), PHP is miles better but it is still trying to play a catching-up game with the big guys (Java and C#) then no.

PHP is playing a game of be a dynamic typed language while it tries to simulate a static typed language. Maybe PHP needs to forks itself and create a new static type language.

PHP and Impostor Syndrome

It is what I have seen

class Customer {
     private $id;
     private $name;
     public function setId(int $id) {
        $this->id=$id;
     }
    public function getId():int {
        return $this-$id;
    }
}

What is the problem with it? The performance of this piece of code is awful. Java could work with this kind of code because Java optimizes the setter and getters. PHP doesn’t have such feature.

And about Laravel, it is a model:

class Customer extends Models {

}
// O_O

So we should guess the fields of customer. We could add some hinting and default values but nothing else much. Also, this model relies in some nasty reflection (__set method). Since Laravel is based in this of code and the model is the core of every functionality of the code, then it is the reason why it is slow.

And Symphony is not better, for example the use of YAML (it has some alternatives)

Article:
  actAs: [Timestampable]
  tableName: blog_article
  columns:
    id:
      type: integer
      primary: true
      autoincrement: true
    title:   string(255)
    content: clob

And Wordpress is not any better

$customers=['id'=1,'name'=>'john'];

However, it gives the best performance and it is more straightforward. However, it will be hard to maintenance.

But why C

Of course, it does not show the whole picture, for example, servers that doesn’t divulge the technology used.

Also, for employment in USA

• python 176k jobs
• java 142k jobs
• javascript 119k jobs
• c# 83k jobs
• php 15k jobs

But again, it is just another measure that it is not complete. For example, Python is more popular than Java, but a Java developer lasts more in a job (the projects are more longest and well paid).

However, why PHP is the more popular (in public websites) and, at the same time, one of the least popular language (in jobs).

For the note:

Many developers have a mis-conception of performance and usability. Example: “my code is slow, however, if I add some framework or library, then it automatically will run better”. Some libraries, specially frameworks, are not performance-wise. They are more focused in stability, validation and general use (and some of them are mainly syntax sugar over anything else).

In Laravel, it is what we do to assign a field:

$object->field='hello';

However, the framework does:

• it validates if the field has mutators. If yes, then it applies it.
• it validates if the field is date
• it validates if the field is cast callable.
• it validates if the field is json castable
• it validates if the field is encrypt castable
• and finally, it assigns the value to an inner array.

And when it validades if the field has mutators, it calls the method studly

public static function studly($value)
    {
        $key = $value;

        if (isset(static::$studlyCache[$key])) {
            return static::$studlyCache[$key];
        }

        $value = ucwords(str_replace(['-', '_'], ' ', $value));

        return static::$studlyCache[$key] = str_replace(' ', '', $value);
    }

Every time.

What is the problem

for($i=0;$i<10000;$i++) {
   $object[$i]->field='hello'; // bye bye performance
}

I regret using PHP was originally published in Cook php on Medium, where people are continuing the conversation by highlighting and responding to this story.

Benchmark array versus object

This benchmark tests the next functionalities:

• Create a variable.
• Then, it reads a simple value
• And it adds to the list (the list is created every round)

And it is an example of the variables used

$array_numeric=[$hello,$second,$third];

$array_not_numeric=['hello'=>$hello,'second'=>$second,'third'=>$third];

$object_constructor=DummyClass('world',0,20.3);

$object_no_constructor=new DummyClass2();
$object_no_constructor->hello='world';
$object_no_constructor->second=0;
$object_no_constructor->third=20.3;

We also test the use of factory, constructor, setter and getters, stdClass and magic methods.

What is a factory? A factory is a function used for creating an entity (in this case, an array).

what is a constructor? A constructor is part of a class and is used to initialize the instance of the object.

Result (smaller is better)

It is the result of the benchmarks in seconds

Result in percentage compared with the smaller result.

Conclusion:

• The difference between an array numeric and an associative array is a mere 5%, so you can say that they are the same.
• The use of an object is +100% slower but it is still acceptable in most conditions (aka it uses the double of time).
• The call to a method or the use of a constructor increases the value considerably. Also, it’s better to use an object/constructor than an array/factory. Why? I don’t know.
• The use of setter/getters impacts the performance considerably. If you can then you should avoid that.
• The use of magic setters and getters is horrible (almost 10 times slower). Is it the reason why Laravel is slow?
• Also, the setters and getters are vanilla, they don’t validate if the field exists of any other validation.
• And the use of a stdClass (anonymous class) is also bad but not as bad as to use setter and getters.

ps: The test ran 1 million times and the difference is smaller than 0.3 seconds, so is it important?

Let’s say we have 100 concurrent users (not a small number but not impossible), and we are processing and returning a list with 1000 values. It is 100x1000 = 100'000 objects. So, if we consider 100'000 objects, then the difference is less than 0.03 seconds in the worst case. However, our systems process more than a single operation, so if we are showing a list of objects, then we also validating, showing other values, validating, reading from the database and storing into the memory and returning to the customer via a web or serialized, so this value could considerable and the use of the CPU is on-top of other processes. It is not a big deal for a small project, but it is important for a big project.

tl/dr

$customer[0]='john'; // faster but it is hard to understand
$customer['name']='john'; // almost as fast as the first one but it is clear to understand (it also uses more memory)
$customer->name='john'; // (where $customer is an object of the class Customer) slower but it still acceptable.
$customer->name='john'; // (where $customer is an object of the class stdClass) the double of slower than to use a class. 
$customer=new Customer('john'); // (constructor) even slower but is still acceptable;
$customer=factory('john'); // (where factory is an array that returns an array). Slower than the use of constructor.
$customer->setName('john'); // bad performance
$customer->name='john'; // (where the class uses a magic method) awful performance, avoid this one.

The code is here (if you want to test it)

https://github.com/EFTEC/php-benchmarks/blob/master/benchmark_array_vs_object.php

PHP, Benchmark time was originally published in Cook php on Medium, where people are continuing the conversation by highlighting and responding to this story.