DEV Community: Felipe Elia

Updating my profile on GitHub

Felipe Elia — Sun, 27 Aug 2023 19:30:13 +0000

It's been a while since it's possible to customize your GitHub profile. I never had any ideas to do something cool, but after watching this video, I used this tool to update my GitHub Profile.

My updated GitHub profile

The process is quite simple:

Create a repository with the same name as your username. In my case, it was https://github.com/felipeelia/felipeelia;
Open the tool, fill in the necessary fields and generate the README.md file;
Push the file to your repository.

There is a GitHub Action that keeps the blog posts list updated, but the reference in the tool is outdated. I already sent a Pull Request with the necessary change, but you can copy it from my repository and adjust it as needed.

Here are some profiles I used as a reference:

Finally, I created an account on Ko-Fi and added that Buy me a coffee button. I don't expect any donations, but if anyone ever wants to, there's an easy way to do it.

Remote work: positions and hiring process

Felipe Elia — Fri, 17 Feb 2023 17:57:10 +0000

Looking for a remote work opportunity but don't know how the hiring process is? In this post, I share some tips on places where to find remote work positions and things about the hiring process I wish someone told me before.

This post is the second part of a series about remote work and international jobs. Check the other post link in the list below. I'll update the list as I publish new texts but don't forget to follow me!

International Jobs: Does my English need to be perfect?

Where to find job opportunities

My content focus is WordPress, so here is a list of places I recommend to find positions related to WP:

The company you like
This should be the obvious starting point. If there is a company you like or admire, you should try it first.

10up
10up is the company I currently work for. I learned and continue to learn a lot of different things there and I can say the experience change my life and career in different aspects. And it is hiring!

WordPress Newsletters
There are a lot of WordPress-related newsletters out there and some of them have a section just to list open opportunities. The newsletters I like to read are MasterWP, WP Owls, and Post Status.

Codeable
Codeable is not a development agency but a freelancer platform. I got many projects there and I recommend it.

Codeable works around all the common pitfalls of these platforms:

The final value of a project is not the cheapest but an average of all values. The client can't see how much each developer wants to charge, so the dev is selected by the messages exchange rather than price.
It has (or at least had) a selection process, assuring good quality from all the freelancers.
Payment is done to Codeable before the project starts and is forwarded to the developer only when it is done, making it a safe place for all parts.

Codeable served as an entry door to the international market and I think it is an excellent option for those who want to start working internationally.

If you have a good place that lists WordPress-related jobs opportunities, leave a suggestion here in the comments!

It is normal not to be called

Don't be afraid to fail. I tried an internship at Automattic twice, and got to the final phases but wasn't accepted. Don't give up and keep studying and trying to get that job!

Remember: You don't lose anything by hearing a NO. Everybody was rejected at least once.

It is time to send your CV!

After you found the company you want, it is time to get noticed. In this step, you will need two things: an updated resumé (CV) and a cover letter.

But before...

We can have a post about hard and soft skills (what do you think?) but know that although tech knowledge is needed, companies look for people that communicate well and want to learn.

It is also worth remembering that first impressions are key, so update everything you have online that is related to work.

Update your LinkedIn, GitHub, and WordPress.org profiles!

CV: concise and with what will draw attention

Your resumé just needs one or two pages, with your main experiences and knowledge (courses, certificates, etc.) There are free templates on the internet with modern visuals and pretty easy to fill out.

See an example below (with the link):

Modern and concise CV Template

Cover Letter

This part can be new for a lot of people. It is just a page of text with a few paragraphs. It should be something specific to the position, so do not send the same cover letter to different places.

There are the items you need to include in your cover letter:

Your personal info (name, location, email, mobile, etc.);
Your connection with the company, where you saw the position;
History, mainly what you are currently doing;
Why you should be hired.

There are a lot of cover letter examples on the web. TIP: The best examples you will find searching on Google Images, not simple text.

Interviews

If they want to interview you, congratulations! It is common to see hiring processes with lots of interviews, made by different sectors. Celebrate each step!

It is time to pay attention to a few things:

Review your equipment: earphones, microphone, and internet connection

Before each interview, make sure your earphones, headsets, and/or microphone are working properly, without any noise or similar. If your wifi is unstable, it is worth using a cable, even if that means sitting near the router for a day or having a long cable across the house for a few hours.

Prior preparation is fundamental

Some questions are classics and you should be prepared beforehand. The basics “Tell us about you”, “which was the most difficult project you worked on?”, “what do you like and dislike in WordPress?” should be on the tip of your tongue.

Know the company and the job position

Showing interest is key in any relationship, of any nature. Knowing a little about the company and the position will demonstrate this interest, giving you some points with the interviewer.

If possible, search for the interviewer

This can help a lot if the interview is in English and you are not so confident. It may sound a bit of a stalker, but finding a talk or video with the interviewer can give you time to learn their accent and familiarize yourself with the way they talk.

An interview is not an interrogatory

You can (and should) ask questions. That also demonstrates interest. An idea is to ask about advantages offered by the company, like days off, paid courses, and equipment.

Live Coding: think out loud

If the hiring process has a live coding step (those sessions when you need to write code with someone else looking over your shoulder), remember to think out loud.

The final code is not always so important. How you are thinking and which steps you are trying to make are what really matters.

Imagine a math test where the final result is obviously relevant but the accounts you made to get to the result also matter.

Conclusion

In this post, we saw some places that offer WordPress-related career opportunities. We also saw it is normal to not get the job on the first attempt. Do not give up!

We also saw some essential things in a good CV and cover letter, as well as important points to keep in mind about what companies are really looking for.

Lastly, we saw that prior planning can be essential in a good interview. Prepare your space and mind can make you feel more comfortable during the interview

International Jobs: Does my English need to be perfect?

Felipe Elia — Fri, 10 Feb 2023 12:08:16 +0000

November last year I gave a talk in WordCamp São Paulo about remote work and finally the text version is here! If you speak Portuguese, the talk is available on YouTube. There is also a pt_BR version of this text.

That was a long talk, so I'm going to publish the text in parts. Do not forget to follow me here to get notifications about the next posts, okay?

Does my English need to be perfect?

This is people's first question when we talk about working for an international company. If you think you need to speak English like a native to get a job, that is a barrier that only exists in your mind.

Understand and be understood are the only things you really need.

That is really it. If you can understand someone speaking in English and if people can understand you speaking English even with your accent (everybody has an accent) you are ready.

Nothing replaces a course

Every once in a while we hear about some superheroes that learned how to speak English all by themselves. That is not the reality for most people though. There are at least two things you most likely have only by attending a course:

Writing practice - Only by practicing you will learn some irregular verbs' past forms (think > thought), how do you spell some words, etc.
Grammar - Knowing the basics will make your life easier when you don't understand a word but get the overall context.

You don't need a 15-year course, that is not my point. You do need to be sure you have the basics of writing and grammar structures.

Movies, TV shows, games, and code lives

I was super afraid of entering into a meeting and not understanding a word people were saying. I started watching TV shows and YouTube videos. First with English subtitles, then with no subtitles at all. This exercise helped me and it still helps me a lot.

Code lives on Twitch also help a lot. There you will hear some jargons that you only read.

Here are some examples that worked for me. At the time I gave the talk I was watching Andor, today I'd say The Last of Us.

Andor (Disney+)

Gameranx (YouTube)

Zanny (YouTube)

RyanWelcherCodes (Twitch)

Real life

Courses, YouTube videos, TV shows... none of that really prepares you for real life. In real life you will need to deal with:

Acronyms and expressions - These folks really love acronyms. EOD, ASAP, and AFAIK are some of them but you will see a lot of new ones when you start. Expressions like Ballpark estimates are also part of this item.
Broken audio - In a movie everybody hears each other without any noise. In real life the video freezes, the audio breaks up, and more. Expressions like Do you mind saying that again? or You broke up a bit I only heard after attending meetings.
Accents - I am lucky to be part of a very plural team. We have American, German, Indian, Hungarian, Mexican, and more. Sometimes it is hard to get one or two explanations but instead of faking you understood, it is better to say I’m not sure I follow… and ask them to explain it in a different way. This happens more than people imagine.

I don't know how courses outside Brazil work but here we learn something like How are you? I'm fine, thanks, and you? In real life, no one really uses that. Pay attention to others and adapt.

When I joined the company, I almost gave up!

I've been part of 10up for 3 years now but I almost quit in my first weeks. We have a daily standup and it was nearly impossible for me to understand one of my colleagues.

I brought that to my leadership team and they told me it was normal and that I would get used to it. I really got used to it after a while.

It can be hard in the beginning. Do not give up!

Here is a tip: always be frank, and never pretend you understood. Companies really value people who know how to communicate well and (as weird as it may sound) part of good communication is saying when something needs to be explained in a different way.

Tools

In addition to Google Translate, there are at least two tools that help me a lot on a daily bases and I think it is worth sharing with you:

Grammarly

Grammarly is a service that helps while writing in English. I use it as a browser extension and it helps me with things like the image.

Google “define:ACRONYM”

As I said, acronyms are very common in English. When I see a new one that I don't know yet, I search for define:ACRONYM in Google and usually, the first result is already enough.

Conclusion

In this first post of the series, we saw that understanding and being understood is the level of English you need to have to try an international job.

Practice in writing and grammar knowledge is essential, so a course is recommended. It doesn't need to be a 10 years course, but a structured study with a few months at least.

Watching something you like as YouTube videos, TV shows, and movies help a lot but with subtitles in English or no subtitle at all. Code lives are also interesting.

Nothing replaces real-life experience. Expressions and trivial problems are not represented in movies and series, so be prepared to learn a lot at the beginning.

I also told a little about my bumpy start and how I almost quit in the first weeks. It is important to persist, it is worth it!

Lastly, we saw some tools you will want to keep near you when communicating in a different language.

This was just the first part! Follow me here and on social networks to be updated about part 2.

WordPress Health Status and the new Report Parser Tool

Felipe Elia — Thu, 02 Feb 2023 10:00:00 +0000

What is your WordPress version? And PHP? How many posts do you have? Status reports gather all those information in a single place. Just copy and paste, and answer all the support questions at once. But what do we do when the report is not easy to read?

Asking the same questions over and over again

Asking or answering the same questions is too boring, everybody agrees. Everybody also agrees that the solution for repeated tasks is automation. If the system knows all the answers, why not get them directly from the source, saving everybody's time? Status or system reports are meant for this.

If the system knows all the answers, why not get them directly from the source, saving everybody's time?

Status report pages are already common in the WordPress ecosystem. Go to a specific page, click on a button, and paste it into a ticket. The report isn't always that legible but I've created a tool to help with that.

The Report Parser Tool

Status pages are divided into sections containing lists of key-value pairs. In WordPress, for example, we have the "WordPress" section, and some keys are "Version", "Site Language", etc. The copy-and-paste report shared with support follows the same format but it gets really hard to read when the value is too big. Imagine a JSON object, for example.

The Report Parser helps with that problem: just paste the report into the textarea and it is possible to see it formatted with collapsible sections.

Screenshot of the Report Parser Tool

The idea to create the tool came after we added the new Status Report page to ElasticPress 4.4.0. There we aggregate answers for lots of common support questions, like the last failed Elasticsearch queries.

With these Elasticsearch queries, I noticed a problem: common lists are easy to read but bigger JSON objects are not. The tool serves as a way back: keep both the easiness of copy-and-paste reports and readability for support teams.

WordPress Site Health Info

WordPress 5.2 added a new page with Site Health Info, previously only available via the Health Check plugin.

Screenshot of WordPress' Site Health Info

The Report Format

After you click on the Copy site info to clipboard button, a report like the one below will be available to be pasted:

### wp-core ###

version: 6.1.1
site_language: pt_BR
user_language: pt_BR
....

### wp-dropins (2) ###

advanced-cache.php: true
object-cache.php: true

As you must have noticed, the basic structure is:

### <section_name> ###

key_1: <value_1>
key_2: <value_2>

Report Parser gets that format and transforms it back into collapsible sections and formatted tables.

How to add your own sections to the WordPress Site Health Info page

Well, as we are already here, let's see how simple it is to add a new section with your plugin or theme info. All we need is to use the debug_information filter, returning the array with a new index.

function my_custom_health_info_section( $debug_info ) {
    $debug_info['section_slug'] = [
        'label'  => __( 'My Custom Health Info Section', 'textdomain' ),
        'fields' => [
            'field_slug_1' => [
                'label' => __( 'Label 1', 'textdomain' ),
                'value' => 'value 1',
            ],
            'field_slug_2' => [
                'label' => __( 'Label 2', 'textdomain' ),
                'value' => 'value 2',
            ],
        ],
    ];

    return $debug_info;
}
add_filter( 'debug_information', 'my_custom_health_info_section' );

The code above creates a new section, like the screenshot below:

Our new section in WordPress Site Health Info

In the copy-and-paste report, our section looks like this:

### section_slug ###

field_slug_1: value 1
field_slug_2: value 2

Status reports in plugins

Some plugins have their own status reports. That happens because they were created before WordPress added this functionality or because their reports are so complex that they don't fit into the WordPress structure, which has only one level of hierarchy.

WooCommerce

WooCommerce's System Status is available under WooCommerce > Status.

Some sections stand out there, like Database, Settings, and WooCommerce pages, super specific to the plugin. In WooCommerce, the copy-and-paste report stays visible, different from almost all other solutions available.

Gravity Forms

Gravity Forms' System Report is available by going to Forms > System Status.

In addition to a section called Gravity Forms, the section Database (pretty much like WooCommerce's) lists all the plugin custom tables.

ElasticPress

The ElasticPress Status Report page was born from a support need and was inspired by several existent solutions.

In addition to extremely specific sections like Indexable Content, Elasticsearch Indices, and Last Sync, the ElasticPress report has another difference: an extra hierarchy level. There we have the WordPress section, for example, with the WordPress Environment and Server Environment subsections.

Conclusion

In this post we saw a new tool called Report Parser, available here in the blog, to better visualize WordPress and its plugins' Status Reports.

We had a look at the Health Info from WordPress itself, the standard format used in all reports, and how it is possible to add your own section to WP's report.

At last, we saw some plugins that have their own reports like WooCommerce, Gravity Forms, and ElasticPress.

Don't forget to share the post and subscribe to the newsletter!

FTP No More: Deploying WordPress sites with GitHub Actions

Felipe Elia — Fri, 27 Jan 2023 13:45:38 +0000

Do you still use FileZilla to send files one by one to the server? It is time to change! After reading this post all you will need is to push a file to a GitHub repository and it will be automatically sent to your server.

If you are in a hurry... that is fine!

There is no problem if you are in a hurry. In summary, this is what we are going to do:

Create an SSH Keys pair to connect to your server;
Create the DEPLOY_SSH_HOST, DEPLOY_SSH_USER, and DEPLOY_SSH_KEY secrets in GitHub;
Create the bin/rsync-excludes.txt file in your repository;
Create the .github/workflows/deploy.yml file in your repository;
Make any changes in the trunk branch.

If this post helps you, don't forget to share it!

What you need

The list of things you need for this post is quite simple:

SSH Acess to your server: Available in almost all host providers nowadays;
A GitHub repository: Free and unlimited, including private ones.

Don't forget to back up your files before you continue. If something goes wrong you will have a way to revert it.

What the GitHub Action will do

Basically, when a file in a certain branch is updated, a GitHub Action will connect to your server via SSH and send the files using the rsync command.

The green ✓ means an Action was executed successfully.

SSH Access

Your GitHub Action will need to connect to your server via SSH (Secure SHell) to send the files. To make that possible, we will create a new pair of SSH keys and configure the server to accept it.

1. Create a pair of SSH keys

The cryptography used by the SSH protocol uses two keys: a public and a private. So your GitHub Action can send the files to your server, you will need a new pair of keys. Although possible, I do not recommend using the same key you use on your computer.

The command to create a new key is the following:

ssh-keygen -t ed25519 -C "user@domain"

ssh-keygen: The command itself;
-t ed25519: The algorithm used in the file creation;
-C "user@domain": It does not need to be a real email. It is only used to differentiate keys, as a comment. Something like deploy@mysite.com is enough.

The command will ask:

A password: leave it empty to make the process easier;
A filename: do not use the default, put something like deploy or the project name. Do not add any extensions.

The ssh-keygen command and its return

2. Authorize the key to connect to your server

Each hosting provider handles this in a different way. In services that provide some sort of dashboard, it can be in My Account > SSH or similar.

On Cloudways, for example, the SSH keys are handled per application. In the Access Details section, it is possible to manage the keys under Application Credentials. (Cloudways also offers a Deployment Via Git option that we are not covering here.)

Cloudways Application Management dashboard

In the image we have arrows pointing to three elements:

Public IP: This will be used as the host in our setting. In many cases, it is the website domain.
Username: Cloudways has a different username per application. Some hosts use the same username for dashboard and SSH accesses.
SSH Keys: This is the place where it is possible to set new keys for this application. There, you can provide the public key (file.pub) of the pair we've generated.

3. Test the SSH key (Optional)

You can use your computer to test the access using the new key. For that, all you have to do is call:

ssh -i <private-key-filepath> <user>@<server>

<private-key-filepath>: The path to the private key file (without.pub) in your computer;
<user>@<server>: It can change depending on the provider. For that screenshot from Cloudways, it would be appname_ssh@12.34.567.890.

If we would use the key generated in our example, the call would look like this:

ssh -i /home/elia/.ssh/exemplopost appname_ssh@12.34.567.890

If you had everything right, you will see the server terminal on your computer.

GitHub Actions

GitHub Actions is GitHub's automation tool. In summary, GitHub will analyze any .yml file in the .github/workflows folder of your repository and try to execute it every time something happens in your repo.

In our case, we will create a file named .github/workflows/deploy.yml. You can name it as you want but you need to keep the .yml extension and the file location.

ATTENTION: .yml files do not allow tabs, only spaces (2 or 4).

Our .github/workflows/deploy.yml file contents will be as follows:

name: Deploy

env:
  SSH_USER: $`{{ secrets.DEPLOY_SSH_USER }}`
  SSH_HOST: $`{{ secrets.DEPLOY_SSH_HOST }}`

on:
  push:
    branches:
      - trunk

jobs:
  deploy_cloudways:
    name: Deploy to Cloudways
    runs-on: ubuntu-latest

    steps:
    - name: Checkout
      uses: actions/checkout@v2

    - name: Configure SSH
      run: |
        mkdir -p ~/.ssh/
        echo "$SSH_KEY" > ~/.ssh/deploy.key
        chmod 600 ~/.ssh/deploy.key
        cat >>~/.ssh/config <<END
        Host cloudways
          HostName $SSH_HOST
          User $SSH_USER
          IdentityFile ~/.ssh/deploy.key
          StrictHostKeyChecking no
        END
      env:
        SSH_KEY: $`{{ secrets.DEPLOY_SSH_KEY }}`

    - name: Send files
      run: "rsync --delete -avO $`{{ env.RSYNC_FLAGS }}` --exclude-from=$`{{ env.EXCLUDES }}` ./ $`{{ env.SSH_USER }}`@$`{{ env.SSH_HOST }}`:$`{{ env.DESTINATION }}`"
      env:
        RSYNC_FLAGS: '' #--dry-run
        EXCLUDES: bin/rsync-excludes.txt
        SSH_HOST: cloudways
        DESTINATION: "~/public_html/wp-content/"

Workflow name

The first line of our file simply gives a name to our workflow. The name is used just for display purposes and does not interfere with the automation functionality.

name: Deploy

Secrets for GitHub Action

The second section of our file configures environment variables to be shared across some steps further up.

env:
  SSH_USER: $`{{ secrets.DEPLOY_SSH_USER }}`
  SSH_HOST: $`{{ secrets.DEPLOY_SSH_HOST }}`

As the description of our workflow is made in a file visible to anyone with read access in the repository, GitHub provides a way to create secrets, editable only by administrators of the repo or organization.

How to create a secret in GitHub Actions

Let's remember the SSH access command we previously used to test:

ssh -i <private-key-filepath> <user>@<server>

With that command in mind, access your repository, and go to Settings > Secrets and Variables > Actions. We will create three secrets:

DEPLOY_SSH_KEY: The content of the private key you created.
DEPLOY_SSH_USER: What you used as <user>;
DEPLOY_SSH_HOST: What you used as <server>;

Note that DEPLOY_SSH_KEY is different from the others: we are using the file path in the command but the secret has the content of the file. This happens because we will create the file during the action execution.

Form to create a secret in GitHub

The DEPLOY_SSH_KEY secret is not in this env section on purpose. It will be used later.

Triggers and Events

on:
  push:
    branches:
      - trunk

The content of this section is quite self-explanatory: the steps in this file will only be executed if the trunk branch changes.

Instead of push, it could be pull_request or schedule, for example.

Jobs

The jobs section is a set of steps to be executed. Our workflow file has only one job but it is possible to have more than one. Different jobs run in parallel.

jobs:
  deploy_cloudways:
    name: Deploy to Cloudways
    runs-on: ubuntu-latest

The deploy_cloudways string could be any slug, the same is valid for Deploy to Cloudways. These are just names.

The ubuntu-latest string specifies under which OS the job will run. It is possible to use different Linux, Windows, and macOS versions. See the full list.

Steps

Steps are the parts that make a job and they are executed in order.

    steps:
    - name: Checkout
      uses: actions/checkout@v2

Our first step is the repository checkout. Usually, this will be the very first step of all the workflows you will see out there. It simply brings the repository content to the action's environment.

SSH Configuration

This section configures SSH of the machine running our action in GitHub.

    - name: Configure SSH
      run: |
        mkdir -p ~/.ssh/
        echo "$SSH_KEY" > ~/.ssh/deploy.key
        chmod 600 ~/.ssh/deploy.key
        cat >>~/.ssh/config <<END
        Host cloudways
          HostName $SSH_HOST
          User $SSH_USER
          IdentityFile ~/.ssh/deploy.key
          StrictHostKeyChecking no
        END
      env:
        SSH_KEY: $`{{ secrets.DEPLOY_SSH_KEY }}`

mkdir -p ~/.ssh/: Creates the .ssh directory inside the $HOME folder of GH's machine.
echo "$SSH_KEY" > ~/.ssh/deploy.key: Puts the content of the SSH_KEY variable inside the deploy.key file.
chmod 600 ~/.ssh/deploy.key: Configures the permissions of the deploy.key file. In this case, 600 means the owner can read and write on it but no one else is able to access it.
cat >>~/.ssh/config <<END: What you see between <<END and END will be inserted in the config file of the .ssh directory.
- Host cloudways: Creates a name for the following configuration. When calling SSH passing cloudways, the data below will be used;
- HostName $SSH_HOST: The server address. If you remember what we talked about the env section, this variable will receive the value of the DEPLOY_SSH_HOST secret;
- User $SSH_USER: Similar to HostName but applied to the user;
- IdentityFile ~/.ssh/deploy.key: Specifies the path of the key to be used when connecting to Host;
- StrictHostKeyChecking no: Skips the server's identity verification with the known_hosts file.

Down below, we can see an env section, similar to that global one (declared at the beginning of our file.) Note that in this case the variable is created only for this step. Here we are passing the content of the DEPLOY_SSH_KEY secret to an environment variable called SSH_KEY. The content of this variable will be added to the deploy.key file, as we saw.

Send files with `rsync`

In the last step, we will finally change the content of the target server. For this, we will use the rsync command, which synchronizes the files from one place to another. Here, the files in GitHub's machine (origin) with the files in your server (target.)

    - name: Send files
      run: "rsync --delete -avO $`{{ env.RSYNC_FLAGS }}` --exclude-from=$`{{ env.EXCLUDES }}` ./ $`{{ env.SSH_USER }}`@$`{{ env.SSH_HOST }}`:$`{{ env.DESTINATION }}`"
      env:
        RSYNC_FLAGS: '' #--dry-run
        EXCLUDES: bin/rsync-excludes.txt
        SSH_HOST: cloudways
        DESTINATION: "~/public_html/wp-content/"

If the rsync command is something new to you, let's give a deeper look into each one of the parameters we are calling:

--delete: If a file does not exist in the origin, also delete it in the target.
-avO: -a is to sync all files, folders, and symbolic links preserving their permissions. That v is for verbose, i.e., outputs to the terminal the list of changes being made. That O (an uppercase "o") tells rsync to not worry about folders' modification dates.
$`{{ env.RSYNC_FLAGS }}`: As you can imagine, this will be replaced with the content of RSYNC_FLAGS, configured a couple of lines below. Usually, it doesn't receive anything but you can pass --dry-run, for example, to simulate what the command would do without changing anything in the real world.
--exclude-from=$`{{ env.EXCLUDES }}`: You can pass the path of a file containing the list of everything that should be ignored by rsync. Check the next section to know more about it.
./: The path (in the origin) that needs to be synced.
$`{{ env.SSH_USER }}`@$`{{ env.SSH_HOST }}`:$`{{ env.DESTINATION }}`: The target path. The last part will be replaced by the folder in the target server. In our case, the repository only contains the wp-content files and the website is located in the $HOME/public_html folder on the server. In your case, the folder can be elsewhere, like /var/www/html. Access your server or search in your host configurations to get where in the server your website files are located.

About exclusions and `rsync`

In the previous example, we are using a file called rsync-excludes.txt located in the bin folder of the repository. This file has a list of files and folders that should be ignored by the rsync command. For example:

*.gitignore
*.gitmodules
*.git
*.gitkeep
*.github

/bin
*rsync-excludes.txt

/uploads
/upgrade
/themes/index.php
/plugins/index.php

Instead of using --exclude-from=<file> you can change the rsync call and use --exclude .git --exclude README.md, for example.

Doing more with GitHub Actions

If you want, it is also possible to call commands like composer install or npm install during the process, so you don't have to version 3rd party files in your repo. In addition to that, the process can also be triggered by a Pull Request creation or time periods (hourly, daily, etc.)

For real examples, give a look at the ElasticPress repository. There you will see actions executed daily, automated tests, deployments to WordPress.org, and more.

Why you should not use SFTP anymore

Firstly, you should be using a version control system like git, even if you work alone. Versioning your projects in a git repo will give you control of your changes and a backup. It is also a requirement in most jobs nowadays.

The process described here has several advantages over the old method of sending file by file using a program like FileZilla, for example. My favorite is that you'll be sending only the files that were changed, making it all easier and faster. We also avoid having different people updating the same file and overwriting changes one from the other.

I used GitHub and GitHub Actions in this post but there are several alternatives available if you want. The process of sending files to a server through a repository is called Continuous Delivery and is part of the Continuous Integration, Delivery, and Deployment topic, also known as CI/CD.

Conclusion

In this post, we saw a method to send files to a server from a git repository.

To access the server, an SSH key pair is needed. The public key is stored in the server, the private key is stored as a secret in GitHub.

We also saw how easy it is to create a workflow in GitHub: we just need to create a .yml file in the .github/workflows folder. To restrict access to sensitive information we can use GitHub secrets.

The sync between files is made through the rsync command, which accepts several parameters. It is also possible to exclude files from the sync through different ways: a list in a file with the --exclude-from parameter or several --exclude.

This post is just a glimpse of what is possible with GitHub Actions. It is also possible to use Composer and NPM during the process and much more.

Lastly, we saw why this deployment method is much better than sending individual files via SFTP.

Don't forget to share the post and leave a comment!

Deprecated code in Open Source (with WordPress functions)

Felipe Elia — Wed, 18 Jan 2023 11:57:43 +0000

Keeping a codebase organized always requires some changes: functions, files, structures, everything someday needs a new name or place. How do we make a change without breaking anything?

Open-source codebases come with several advantages but some specific challenges. Different from a service that simply provides a more strict API, like a REST API, for example, others can call almost anything in your code. That said, you must be cautious even while renaming the simplest function.

Although all this can sound painful, it is not. Keeping your codebase organized is worth it!

Make the change in phases

Simply renaming the function is not a good idea: any solution depending on it will suddenly break. You need to warn that action will be needed and, after enough time, really implement the new solution.

To define what and when needs to be changed, we can use Semantic Versioning.

Semantic Versioning

Semantic Versioning gives meaning to the numbers of a software version, aligning expectations of what can happen in each new release.

The following table summarizes what would be the major, minor, and patch version number of a software in its 2.4.3 release, in addition to what we could expect from the upcoming 2.4.4, 2.5.0, or 3.0.0 releases.

Major (2.4.3)	Minor (2.4.3)	Patch (2.4.3)
Changes that do break backward compatibility	New features that do not break backward compatibility	Bug fixes only
Updating to version 3.0.0 requires attention, as the current solution can break	Updating to version 2.5.0 means that everything continues to work but with some new functionality	Updating to version 2.4.4 means some bugs were fixed

Practical Example

Keeping both the function rename example and our 2.4.3 version in mind, let's see how we could plan that out. Let's split the process into some steps and define their release versions.

Version 2.5.0: Implement new code and change the old code without breaking it

Implement the new code. It doesn't matter if it is a renamed function or a brand-new method, the new code needs to be there so people can do the switch;
Change the old code. In case it is just a simple switch, the old code needs to become a wrapper of the new function with a warning about the (now) wrong usage;


function new_name( $parameter ) {
    // Do something
}

function old_name( $parameter ) {
    _deprecated_function( __FUNCTION__, '2.5.0', 'new_name' );
    new_name( $parameter );
}

Note that calling old_name() still works but a warning was added there saying that starting from version 2.5.0 new_name() is the function that should be called.

Version 3.0.0: Remove the old code

After warning for long enough, you can remove the old code. Attention: this removal is expected to happen in a major version.

You do not need to remove the code in the immediate following version, though. Depending on your user base and your release calendar you can wait for any major version, like 4.0.0 or 5.0.0, for example.

A project that just releases a major version per year can have a slightly different approach from a project that releases a major version per month.

Move deprecated code into separate files

One of the intentions behind these changes is to keep your codebase clean and organized. With that in mind, keeping these functions in your main files can make you uncomfortable as things can actually look messier than before.

Some development teams move these pieces of code to specific files, named deprecated.php, for example. In addition to a readability increase, this also helps when you need to identify which code can be removed while launching 3.0.0.

The more you communicate, the better

In the example above we called the _deprecated_function() WordPress function but that will only have an effect if the WP_DEBUG constant is set to true.

Unfortunately, quite often these warnings are useless: in many cases, people are not paying any attention to logs. You also need to warn your users in an accessible and human-readable way.

Inform your users about important changes in all ways possible: logs warnings, items in your changelog, blog posts, and even social media if needed.

Changelog

The best place to communicate changes in your software is in its changelog. In WordPress, this type of log is kept in a specific section of the readme.txt file and is displayed on both the plugin page and in a modal inside the Dashboard.

Using Akismet as an example, this is the link to see the next version's details.

Plugins list in WordPress's Dashboard. The yellow notice is delayed when there is a new version of the plugin.

Clicking on the link will open a modal with the changelog:

Modal with the plugin's changelog. Versions are usually ordered from the newest to the oldest.

WordPress gets that information from the == Changelog == section of the readme.txt plugin's file, hosted in WP.org official repository:

Akismet's readme.txt file

Usually, changelogs are divided into sections, separating what was added, changed, fixed, removed, and deprecated. An example of this division can be seen in both ElasticPress's release notes and its changelog.

WordPress Functions

WordPress has some functions that help to inform the usage of deprecated code. Here is the list:

_deprecated_function( $function, $version, $replacement = '' )

This function is in the example we used before. A simple way to mark a function as deprecated.

apply_filters_deprecated( $hook_name, $args, $version, $replacement = '', $message = '' )

This and the next are wrappers for _deprecated_hook(), which is not part of this list, as it should not be called directly. As the name says, this function applies a filter but also informs it is deprecated and, if available, provides its proper replacement.

do_action_deprecated( $hook_name, $args, $version, $replacement = '', $message = '' )

Similar to the last one but applied to an action.

_doing_it_wrong( $function, $message, $version )

Although not necessarily related to deprecated code, I'm adding _doing_it_wrong() to the list as it can be super useful when the change requires more attention than a simple name change.

_deprecated_argument( $function, $version, $message = '' )

As the name implies, this is for a change in an argument.

Although always related to an argument, there are a couple of different scenarios where this function can be used:

A change in the expected value of an argument like 'blacklist_keys' that is now 'disallowed_keys';
An argument that does not exist anymore;
An index of an array argument. Let's say, before $args['cat'] was expected but now it is $args['taxonomy'].

_deprecated_file( $file, $version, $replacement = '', $message = '' )

Marks an entire file as deprecated. Usage examples are renamed files or files that are not needed anymore. The wp-includes/class-json.php file calls that function, as since WP 5.3.0 the native PHP extension is required.

_deprecated_constructor( $class, $version, $parent_class = '' )

This is related to object constructors. Years ago, constructors methods in PHP had their class name but since PHP 5.4 the recommended way is using the magic __construct() method. Class name constructors are deprecated since PHP 7.0 and should not be used anymore.

Obsolete vs. deprecated

Each language has its own specificity. For Brazilian Portuguese, for example, we don't have a specific word for "deprecated". People quite often wrongly translate that as "depreciated." So, we use obsolete and deprecated interchangeably.

In English, those two words refer to different states of the code: deprecated code is still functional and present, obsolete code usually doesn't work anymore, and/or was removed from the codebase.

Conclusion

Keeping your codebase clean and organized is essential. To make the needed changes and keep retro compatibility you need to plan the changes in phases.

Semantic Versioning can help you to plan which changes are shipped in which versions, so your users are not caught off guard.

Communicating changes through your changelogs also brings more visibility to actions your users will need to take. Specific sections listing those changes help even more.

We also saw some WordPress functions that can help to inform changes in several different scenarios.

Lastly, we saw how these terms can vary in different languages and the difference between deprecated and obsolete.

Is labeling Pull Requests messages a good idea?

Felipe Elia — Sun, 08 Jan 2023 20:50:06 +0000

Reviewing a Pull Request is always a challenge: how do we keep quality and code consistency while keeping developers motivated? Does labeling Pull Requests messages make things easier to interpret?

Recently, I tweeted about the https://conventionalcomments.org/ website. The idea is simple: every time you review a PR, your messages should start with a label, making it clear which is the next expected step (if any.)

E aí, já me segue no Twitter?

What is a Pull Request (or Merge Request?)

A Pull Request is a request to add some code to the project's "official" code. Depending on the tool, these requests can be called Merge Requests.

It goes like this:

Person A:
- Writes some code for a specific change or addition
- Opens a PR describing what and why has been changed;
A revision and adequation process happens. Part of this process can depend on a Person B review.
The code is merged.

This post refers to messages from Person B to Person A explaining the changes needed before the code can be merged.

DISCLAIMER: There is a lot of material about PR etiquette. This post does not cover this specific topic but I do recommend you to search about it. Although just vaguely related, I recommend you to watch this video by Dave Farley about leadership and how important it is to allow people to solve problems in ways you would not do it.

Prefixes and labels: Agreements about the format

The website suggests the following format for revision comments on Pull Requests:

<label> [decorations]: <subject>

[discussion]

For example:

suggestion (test,if-minor): It looks like we're missing some unit test coverage that the cat disappears completely.

I am not sure if this is a big problem or not. Would it be possible to add tests for that scenario before we merge this?

In the example we have:

Label (Ex.: suggestion):
The suggestion label indicates this is about a possible improvement. What and why should be changed.

Decorators (Ex.: test, if-minor):
A quick way to expand the label meaning. The comment is about tests and the decision of whether it should block or not the merge is up to the PR author, depending on the size of the problem.

Subject:
The main message of the comment.

Discussion:
It is not required but can help to further explain the subject.

The website has very good suggestions for labels and decorators.

Two highlights: nitpick and praise

From the entire list, there are two that I found very interesting: nitpick and praise.

The nitpick label is a good way to say "This is not wrong but I would do this differently". I recommend you to pay attention and not overuse this but this label can be a good way to share knowledge.

The praise label is for compliments. This is one way to recognize a good, creative, and/or elegant solution. As each comment creates a thread, the team can agree that the author can "resolve" it right after reading it.

What do you think about this? Share your thoughts in the comments section below or via social networks!

Will PHP 7.2 be the minimum required version for WP 6.2?

Felipe Elia — Sun, 18 Dec 2022 21:23:21 +0000

Yes, this is real! It seems that starting from WordPress 6.2 the minimum PHP version required by WP will be 7.2. The last change in that aspect of the software was made in May 2019, for WordPress 5.2.

The update did not happen before because the team set 5% as the maximum threshold of version usage. According to this ticket, PHP 5.6 usage finally dropped below that. As PHP doesn't have version 6 and versions 7.0 and 7.1 have usage numbers even lower, the minimum version would be bumped to PHP 7.2. The numbers are also available on the Stats page of WP.org.

As of 17 Dec 2022 [...]:

PHP 5.6 is at 4.99% of all WordPress sites
PHP 7.0 is at 2.68%
PHP 7.1 is at 1.82%
https://core.trac.wordpress.org/ticket/57345

WordPress and PHP's timeline

To increase backward compatibility, WordPress adopts a strict policy regarding minimum PHP versions. PHP 5.2, for example, had its final version released in January 2011 but it was supported by WP until 2019.

PHP 5.6 reached its end of life in December 2018 and today, 4 years later, it is still the minimum required version by WordPress. If the change really happens, we will be still behind: PHP 7.2 saw its last version released in November 2020, two years ago.

Out of curiosity, while I write this post, the oldest version still receiving updates is PHP 8.0, with end-of-life planned for November 2023. The latest version, 8.2, was released this month and will receive security updates until December 2025.

	PHP End Of Life	End of Support By WP
PHP 5.2	01/2011	05/2019 (WP 5.2)
PHP 5.6	12/2018	??/2023 (WP 6.2)
PHP 7.2	11/2020
PHP 8.0 (current version)	11/2023

What the PHP version changes for WordPress

Beyond improvements in security and speed, changing the PHP version also makes available a set of new features, modernizing the codebase and decreasing the chances of bugs.

You can see the full list of features that would be available in these three links: PHP 7.0, PHP 7.1, and PHP 7.2. Below you can see just some examples of what we would get just setting PHP 7.0 as the minimum:

Return type declarations

Since PHP 7.0 it is possible to declare the type returned by a function or method:

function example( array ...$arrays ): array {}

Although it is common in some other languages, type declarations (for parameters and return) can be something new to some.

The biggest advantage of this feature is static analysis of code: even without executing the code, it is possible to identify if example() is being called without expecting an array. If that is the case, the error can be detected and fixed before any other test is executed.

The majority of IDEs already have that function built in nowadays.

Null coalescing operator (??)

Instead of writing

$username = isset( $_GET['user'] ) ? $_GET['user'] : 'nobody';

it would be possible to write its simplified version:

$username = $_GET['user'] ?? 'nobody';

Spaceship operator (<=>)

Commonly used for comparison functions, this operator returns -1, 0, or 1 depending on the comparison result.

echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

PHP 8 Compatibility and WordPress Versions

Keeping compatibility with a so wide range of versions makes things harder. Compatibility with PHP 8 (8.0, 8.1, and 8.2) is still in Beta. Will dropping support to PHP 5.6 give enough room to focus on PHP 8.x? Let's hope so!

And you, did you already update your PHP site version?

"WordPress with capital P." Does it matter?

Felipe Elia — Mon, 24 Oct 2022 23:51:21 +0000

If you are looking for a job in the WordPress ecosystem or if you run a business specialized in WP, can a single letter make any difference? The short answer is yes, that single letter can help (or not) to show knowledge and attention to detail.

Looking for a WordPress-related job? Review your CV and make sure you have WordPress spelled right.

Why does it make a difference?

Different communities have different degrees of concern with their characteristic. For the WordPress community, the importance of how its name is spelled sometimes may seem disproportionate.

Anyway, the truth is that WordPress is the only correct way to write it. All the others are wrong and, although it is ignored on most occasions, during a hiring process it can indicate a lack of knowledge or attention.

How much that really makes any difference varies a lot. It can be essential, it can be a tiebreaker, or not be important at all. Nonetheless, if you know the right way to write it, it is always better to use it.

Isn't that too much?

It could be. The fact is that there is a right way and WordPress core even has a function just to make that change: capital_p_dangit(). The function description can give you an idea of how important some folks consider WordPress name spell:

Forever eliminate “Wordpress” from the planet (or at least the little bit we can influence).

Quite severe, right?

A specialist would never write Wordpress or Word press

A person or a company that claims themselves as a WordPress specialist should've already stumbled upon this information. In summary, here are the most important points:

Writing it right does not make anyone a specialist but
Writing it wrong does make someone less of a specialist;
There are people out there writing it wrongly who know more about WP than people writing it right;
It is okay to write wordpress (all lowercase), wp, or WP in informal communications like slack messages. Wordpress and Word press are more noticeable mistakes.

First impressions are important and on some occasions, we need to assure that someone knows or does not know WordPress. If writing it right can't give total certainty, writing it wrong certainly does not help.

As last, imagine this convo:

– Hey, do you like video games? Which are your favorite characters?
– I love it! I like that green dude Zelda, green Mario, and Yellow Sub-Zero!
– Oh, you mean Link, Luigi, and Scorpion, right?
– Yeah, yeah!

Does that mean the person is a bad player? Absolutely not! It does mean they do not read much about the topic, though.

My first contact with this

I want to tell you how I was first told about this difference:

After meeting the WordPress community here in Curitiba in May 2016, I asked if I could give a talk the next month. When I sent my slide deck, Daniel Kossmann asked for a change: WordPress has a capital P.

I had been using WP for years at that point but didn't have any contact with the community. After that day, I never wrote it wrong again.

A picture of that talk! :)

In fact, for any talks in WordCamps, WordPress docs demand the usage of a capital P all the time. Obviously, that rule also applies to meetups or any official community event.

Writing Wordpress can indicate "just" lack of attention

I want to write a post about soft skills and personal characteristics not necessarily related to technology but one thing is certain: no one likes people that do not pay attention.

That said, always review and be careful with your resumé and official communication.

I am a client or I have a job to offer. How much does that matter?

As you can imagine, it depends. If you had a recommendation from someone else, that should matter more than a single letter in a name. If the company or person is completely new to you, that can indicate that their knowledge of WordPress is not that good.

If that is a lead role or something critical to your company, I recommend you to give a look at some other competitors. If this detail passed unnoticed, something else could too.

Okay, what is next?

Now that you know, spread the word. Do not judge those who didn't see this detail yet but explain that this can make a difference. Be nice though, no one has the obligation to know it :)

The thumbnail was made using https://www.thewordfinder.com/simpsons-chalkboard/

WordPress, Object Cache, and Redis

Felipe Elia — Mon, 15 Aug 2022 22:03:00 +0000

Originally published at my blog.

Do you want to make your WordPress website faster while leveling up your WP programming skills? Object Cache may be your answer!

Before we go into Object Cache… What is cache?
WordPress Object Cache
How to “store” things in memory? Redis or Memcached
- What do I need to use WordPress Object Cache with Redis?
The Redis Object Cache WordPress plugin
- Same Redis for different sites at the same server
How the Object Cache plugin works
Let’s give a look at some code
Cache functions available in WordPress
- Key, value, group, and expiration
- Expiration
  - Event-driven
  - Time-driven
Transients API and Object Cache

In the What is an API post, I've briefly mentioned WordPress Object Cache and how I am using Redis here in the blog. In this post, we will give a better look into both of those things.

Before we go into Object Cache... What is cache?

Before we start talking about Redis, we need to talk about Object Cache. And before we talk about Object Cache -- you saw it coming -- we need to talk about cache in general.

Looking for definitions of what is cache on the Internet, common sense seems to be something like this:

Cache is an intermediate storage with quick access, placed between the consumer and the main storage, potentially saving a longer trip.

Look at the example below. In the first request, we go all the way through the origin server but the server cache saves a copy of the response. In the second request, the copy is served, saving time by not going to the origin server.

Image credits: KeyCDN blog.

With that in mind, we can start thinking about all the several trips needed to visit a website and all the intermediate steps we can insert to save time:

Browser cache	Between your browser and the site server, if there is a valid copy of the page on your computer, we save a trip. In fact, we save the entire trip in this case.
CDN	If you are using a CDN like Cloudflare on your website and if there is a valid copy of the content in the CDN, there is no reason to ask for a new copy. It is enough to send just the copy and we save a trip.
WP's cache	In your WordPress website, if a post was already brought from the database and if the version of the post in memory is still valid, why go to the database again?

There are lots of other intermediate places we could save a version of the information, these are just some examples.

WordPress Object Cache

WordPress Object Cache is simple and understand how it works can make the difference during your next job interview ;-)

As I said in the What is an API post, memory access is always faster than disk access. With that in mind, if we brought a post from the database and put that in memory, we do not need to go to the database to fetch it again.

The image quality is not very good but the image is great to understand the relationship between storage and speed.

The problem is that in WordPress default implementation, it will be in memory only until the end of the request. If the user refreshes the page, we will need to go to the database again.

MySQL is smart enough to notice if a piece of information was requested recently and will make it available in a quicker way (basically storing it in its own memory part). Although faster, it will not be as faster as not going to MySQL at all.

By default, this post (or any other piece of info we want) requested at the beginning of the execution is stored using a class called WP_Object_Cache. Its main goal is to save trips to the database and it works basically using key-value pairs. The problem is, like I said, all that only lasts one request. For the next one, we have to do everything again.

How to "store" things in memory? Redis or Memcached

Softwares like Redis or Memcached are in-memory databases. They can do more than that -- especially Redis -- but for our problem with WordPress, its key-pair value in-memory storage is everything we need.

In this post, I will use Redis as an example but Memcached installation and usage are very similar.

What do I need to use WordPress Object Cache with Redis?

The requirements to use WordPress Object Cache with Redis are quite simple:

A WordPress website
Redis running in your infrastructure
A WordPress plugin to connect WP to Redis

The best way to have step #2 done is to contact your hosting provider. On Cloudways, for example, you need to click on a button on their Dashboard to install Redis.

The Redis Object Cache WordPress plugin

As I said in the other post, the plugin I use is Redis Object Cache. Install and configure it is not hard. Out of the box, it will try to connect to a Redis instance in the same server (127.0.0.1) on port 6379 using Redis database number 0.

To have the plugin working, it will need to copy its object-cache.php file from its own includes folder to the wp-content folder of your WordPress installation. If for whatever reason like directory permissions, it is not possible to copy the file automatically, you will need to copy it manually.

Same Redis for different sites at the same server

I have another blog running on this same server, sharing the same Redis installation. To avoid conflicts between stored information for each site, I had to define define( 'WP_REDIS_DATABASE', 0 ); on one and define( 'WP_REDIS_DATABASE', 1 ); on the other.

To adjust the configuration you will need to place some constants in your wp-config.php file. The full list of settings is available on the plugin wiki.

How the Object Cache plugin works

Inside the wp_start_object_cache() function (see below), executed at the beginning of WordPress load flow, WP will detect if there is an object-cache.php drop-in or not. If it is available, the file is loaded, otherwise, the default implementation is used. After that, the cache is initiated.

function wp_start_object_cache() {
    ...
        if ( file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
            require_once WP_CONTENT_DIR . '/object-cache.php';
            ...
        }
    ...
 

    // If there is no external cache, loads WP's.
    if ( ! wp_using_ext_object_cache() ) {
        require_once ABSPATH . WPINC . '/cache.php';
    }
 
    require_once ABSPATH . WPINC . '/cache-compat.php';
 
    ...
    wp_cache_init();
    ...
}

Redis Object Cache's object-cache.php contents can be seen here. It is formed by an implementation of the WP_Object_Cache class (last part of the file) and the several functions that use it like wp_cache_add, wp_cache_get, and wp_cache_delete.

Let's give a look at some code

If you need some code to understand things better that is okay, I am one of those too. Here is a part of the code executed when you call get_post( 123 ); in WordPress 6.0.1.

The code starts in wp-includes/post.php, where get_post calls WP_Post::get_instance( $post ).

Then, in wp-includes/class-wp-post.php:

final class WP_Post {
    ...
    public static function get_instance( $post_id ) {
        $_post = wp_cache_get( $post_id, 'posts' );

        if ( ! $_post ) {
            ...
            wp_cache_add( $_post->ID, $_post, 'posts' );
        } 
        ...
    }
}

At first, it checks if the cached value exists (wp_cache_get). If it exists it is used, otherwise, the post is fetched and then cached (wp_cache_add).

If we look at the wp_cache_add function code, we can see it is nothing more than a simple wrapper for the add method of the WP_Object_Cache instance stored in the global variable $wp_object_cache.

function wp_cache_add( $key, $data, $group = '', $expire = 0 ) {
    global $wp_object_cache;
 
    return $wp_object_cache->add( $key, $data, $group, (int) $expire );
}

Cache functions available in WordPress

The official documentation lists some of the most important cache functions and I am transcribing them here. WordPress's core itself uses them in several places but you can call them too in your theme or plugin.

wp_cache_add( $key, $data, $group = '', $expire = 0 ) // If exists, do not overwrite
wp_cache_set( $key, $data, $group = '', $expire = 0 ) // If exists, overwrite
wp_cache_replace( $key, $data, $group, $expire ) // If does not exist, do nothing
wp_cache_get( $key, $group = '', $force = false, $found = null )
wp_cache_delete( $key, $group = '' )
wp_cache_flush()

Key, value, group, and expiration

Most of the wp_cache_* functions use four parameters:

Key: the identified for the object stored in cache. The post ID, for example.
Value: the object stored in cache. In our example, the post.
Group (optional): You can optionally group values. Previously, it was used simply to organize things but coming in WordPress 6.1, there will be a new wp_cache_flush_group function to flush all objects of a certain group. You will be able, for example, to delete just keys of a certain plugin.
Expiration (optional): for how long a cached value should be considered valid. Let's give it a closer look now.

Expiration

When we talk about cache, one of the most important concepts is expiration. Is the information we have still valid? This is a key part of any cache implementation, including WordPress Object Cache.

So, how do we decide for how long a cached object should be considered valid?

Event-driven

Let's say you are caching the list of posts of the biggest content. You get all the posts, apply the the_content filter in all of them, and check how many characters they have. Pretty intensive, right? This deserves to be cached.

What can change the result of this process? Only if a post is created, deleted, or edited, right?

In this case, our cache does not need to expire. It is enough to invalidate the result we have using a related hook.

Time-driven

If what you are caching comes, for example, from something external like an API, the event that invalidates the cache is not under our control. In this case, we need to check the results from time to time in the external API and update the value we have stored.

Transients API and Object Cache

If you read the post or watched the YouTube video about the WordPress Transients API, the central idea here is not new: a key-value pair that avoids a long process is the essential idea behind both things. In fact, in a certain aspect, it is indeed the same thing. Look at the implementation of the get_transient function:

function get_transient( $transient ) {
    if ( wp_using_ext_object_cache() || wp_installing() ) {
        $value = wp_cache_get( $transient, 'transient' );
    } else {
        ...
    }
    ...
}

Basically, if you are using an external mechanism for Object Caching, the transient will be stored there. Otherwise, the regular database will be used. Interesting, huh? Make sure to check that content too!

WordPress, Object Cache e Redis

Felipe Elia — Mon, 15 Aug 2022 21:55:04 +0000

Originalmente publicado no meu blog.

Quer um jeito fácil de deixar o seu site WordPress mais rápido e ainda por cima dar um up no seu nível de programação com WP? O Object Cache pode ser a resposta para as duas coisas!

Índice

Antes de Object Cache… O que é cache?
O Object Cache do WordPress
Como “gravar” coisas na memória? Redis ou Memcached
- O que eu preciso para usar Object Cache com Redis no WordPress?
O plugin Redis Object Cache
- Mesmo Redis com diferentes sites no mesmo servidor
Como o plugin de Object Cache funciona
Dando uma olhada em código
As funções de cache disponíveis no WordPress
- Chave, valor, grupo e expiração
- Expiração
  - Baseado em um evento
  - Baseado em tempo
Transients API e Object Cache

No post sobre o que é uma API, comentei brevemente sobre o cache de objetos do WordPress e como eu uso o Redis aqui no blog. Nesse post vamos dar uma olhada melhor nessas duas coisas.

Antes de Object Cache... O que é cache?

Antes de falarmos sobre Redis, precisamos falar sobre Object Cache. E antes de falarmos sobre Object Cache, você adivinhou, vamos falar rapidamente sobre cache em geral.

Procurando por definições sobre o que é cache na internet, o senso comum parece ser algo como o seguinte:

Cache é um lugar de armazenamento intermediário e acesso rápido, localizado entre o consumidor e o armazenamento principal, potencialmente economizando uma viagem mais demorada.

Veja o exemplo abaixo. Na primeira vez a requisição vai até o servidor final, mas o servidor de cache guarda uma cópia. Na segunda vez é servida a cópia, economizando a viagem até o servidor.

Peguei a imagem lá no blog do KeyCDN.

Com isso em mente, podemos pensar nas várias viagens necessárias para abrir um site e nos vários intermediários que podemos inserir para economizar viagens:

Browser cache	Entre o seu navegador e o servidor do site, se houver uma cópia válida do site no seu computador, economizamos uma viagem. Na verdade, a viagem inteira nesse caso.
CDN	Se seu site passar por um CDN como Cloudflare e se o conteúdo gravado no CDN ainda for válido, não há porque solicitar uma nova cópia, basta enviar a antiga e economizamos uma viagem.
Cache do WP	No seu site WordPress, se um post já foi trazido do banco de dados uma vez, se a informação que temos na memória ainda é valida, por que ir até o banco de dados novamente?

Existem muitas outras viagens em que podemos adicionar um lugar intermediário para salvar uma versão da informação esses são só alguns exemplos. Ah, e a pronúncia é a mesma que CASH (dinheiro), não cachê ou qualquer outra coisa.

O Object Cache do WordPress

O Object Cache do WordPress é simples e entender como ele funciona pode ser um diferencial na sua próxima entrevista de emprego ;-)

Como falei no post sobre o que é uma API, acesso a memória é sempre mais rápido que acesso a disco. Com isso em mente, se no início do processamento de uma página já trouxemos um post para memória, não há necessidade de irmos no banco novamente para buscá-lo.

A qualidade não é das melhores, mas a imagem é ótima para entender a relação entre armazenamento e velocidade.

O problema é que, na implementação padrão do WordPress, ele só ficará na memória até o fim do processamento daquela página. Precisa dele novamente se o usuário recarregar a página? Vamos ter que ir no banco de dados novamente.

O MySQL é inteligente o suficiente para notar se uma informação já foi solicitada recentemente e deixá-la disponível mais rapidamente, mas mesmo assim não é tão rápido. E, no fim das contas, se estamos indo até o MySQL, estamos fazendo uma viagem maior de qualquer forma.

Por padrão, esse post solicitado no começo do processo (ou qualquer outra informação que quisermos) é gravado usando uma classe chamada WP_Object_Cache. Seu objetivo principal é economizar viagens ao banco de dados e ela funciona basicamente como um par chave-valor. O problema, como eu disse, é que isso tudo só dura uma requisição. Para a próxima, fazemos tudo de novo.

Como "gravar" coisas na memória? Redis ou Memcached

Programas como Redis ou Memcached são bancos de dados que armazenam informações em memória. Eles podem fazer mais do que isso, principalmente o Redis, mas para o nosso problema com o WordPress, o armazenamento em memória de pares chave-valor do Redis é tudo o que realmente precisamos.

Ao longo do post vou usar o Redis como exemplo, mas a instalação e utilização com memcached é bem parecida.

O que eu preciso para usar Object Cache com Redis no WordPress?

A lista de pré-requisitos para usar o Object Cache do WordPress com Redis é bem simples:

Um site WordPress
Redis funcionando na sua infraestrutura
Um plugin WordPress para conectar o WP ao Redis

Para o segundo item, o mais rápido é entrar em contato com sua empresa de hospedagem. Na Cloudways, por exemplo, você precisa apertar um botão no Painel para instalar o Redis.

O plugin Redis Object Cache

Como eu disse no outro post, o plugin que eu uso é o Redis Object Cache. Instalá-lo e configurá-lo é relativamente simples. Por padrão, ele tentará se conectar a uma instância do Redis localizada no próprio servidor (127.0.0.1) na porta 6379 usando o banco de dados Redis de número 0.

Para que o plugin funcione, ele precisa copiar o arquivo object-cache.php de dentro de sua própria pasta includes para a pasta wp-content da sua instalação WordPress. Se por qualquer motivo, como permissão de diretórios, não for possível copiar o arquivo automaticamente, será necessário copiá-lo manualmente.

Mesmo Redis com diferentes sites no mesmo servidor

O meu outro blog, o Melancia na Cabeça, também é armazenado neste servidor e compartilha a mesma instalação do Redis. Para evitar que os valores armazenados pelos dois sites entrem em conflito, eu precisei definir define( 'WP_REDIS_DATABASE', 0 ); em um e define( 'WP_REDIS_DATABASE', 1 ); no outro.

Os parâmetros de configuração diferentes do padrão precisam ser adicionados no arquivo wp-config.php do seu site. A lista completa de parâmetros está na wiki do plugin.

Como o plugin de Object Cache funciona

Na função wp_start_object_cache() (trechos abaixo), executada no início do fluxo de carregamento do WordPress, ele detecta a existência ou não do drop-in object-cache.php. Se disponível, o arquivo é carregado, caso contrário a implementação padrão entra em ação. Então, o cache é instanciado.

function wp_start_object_cache() {
    ...
        if ( file_exists( WP_CONTENT_DIR . '/object-cache.php' ) ) {
            require_once WP_CONTENT_DIR . '/object-cache.php';
            ...
        }
    ...
 

    // Se não houver object cache externo, usa o padrão do WP.
    if ( ! wp_using_ext_object_cache() ) {
        require_once ABSPATH . WPINC . '/cache.php';
    }
 
    require_once ABSPATH . WPINC . '/cache-compat.php';
 
    ...
    wp_cache_init();
    ...
}

O conteúdo do drop-in object-cache.php do Redis Object Cache pode ser visto aqui. Ele é formado por uma implementação da classe WP_Object_Cache (mais pro final do arquivo) e das várias funções que a utilizam como wp_cache_add, wp_cache_get e wp_cache_delete.

Dando uma olhada em código

Se você precisa de código para entender as coisas melhor, eu entendo. Também sou assim. Aqui está uma parte do caminho executado quando você chama get_post( 123 ); no WordPress 6.0.1.

O código começa em wp-includes/post.php, onde get_post chama WP_Post::get_instance( $post ).

E então em wp-includes/class-wp-post.php:

final class WP_Post {
    ...
    public static function get_instance( $post_id ) {
        $_post = wp_cache_get( $post_id, 'posts' );

        if ( ! $_post ) {
            ...
            wp_cache_add( $_post->ID, $_post, 'posts' );
        } 
        ...
    }
}

Primeiro se verifica se o cache existe (wp_cache_get). Se existir é usado, senão o post é buscado e salvo no cache (wp_cache_add).

E só para dar uma olhada no conteúdo da função wp_cache_add, veja como ela nada mais é que um envelope para o método add da instância da classe WP_Object_Cache armazenada na variável global $wp_object_cache.

function wp_cache_add( $key, $data, $group = '', $expire = 0 ) {
    global $wp_object_cache;
 
    return $wp_object_cache->add( $key, $data, $group, (int) $expire );
}

As funções de cache disponíveis no WordPress

A documentação oficial lista algumas das funções de cache mais importantes e estou transcrevendo-as aqui. O próprio core faz uso delas em vários lugares, mas você também pode chamá-las em seu tema ou plugin.

wp_cache_add( $key, $data, $group = '', $expire = 0 ) // Se existe, não sobrescreve
wp_cache_set( $key, $data, $group = '', $expire = 0 ) // Se existe, sobrescreve
wp_cache_replace( $key, $data, $group, $expire ) // Se não existe, não faz nada
wp_cache_get( $key, $group = '', $force = false, $found = null )
wp_cache_delete( $key, $group = '' )
wp_cache_flush()

Chave, valor, grupo e expiração

A maioria das funções wp_cache_* usam quatro parâmetros:

Chave: o identificador do objeto armazenado em cache. O ID do post, por exemplo
Valor: o objeto armazenado propriamente dito. O próprio post.
Grupo (opcional): o grupo serve para -- você adivinhou -- agrupar diferentes chaves. Antes servia mais para organização, mas no WordPress 6.1, será possível chamar a nova função wp_cache_flush_group para apagar todos os objetos de um determinado grupo, como por exemplo, tudo armazenado em cache de um determinado plugin.
Expiração (opcional): por quanto tempo o cache é considerado válido. Vamos dar uma olhada mais a fundo nisso.

Expiração

Quando falamos de cache, um conceito importantíssimo é tempo de expiração. A informação que temos ainda é válida? Essa é uma parte chave de qualquer implementação de cache, incluindo o Object Cache do WordPress.

Então, como decidimos por quanto tempo um objeto em cache deve ser considerado válido?

Baseado em um evento

Vamos supor que você está armazenado em cache a lista de posts com maior conteúdo. Você pega todos os posts, passa o filtro the_content em todos eles e mede quantas letras cada um tem. Bem intenso, certo? Isso merece ser armazenado em cache.

O que pode fazer o resultado deste processo mudar? Só um post novo ser criado ou algum existente ser editado, certo?

Neste caso, nosso cache não precisa expirar. Basta invalidar o resultado que temos usando um hook relacionado, nesse caso, a criação de um novo post ou edição de um post que já existe.

Baseado em tempo

Se o que você está armazenando vem, por exemplo, de um ambiente externo como uma API, o evento que invalida o cache não está sob nosso controle. Neste caso, precisamos verificar o resultado de tempos em tempos na API externa e atualizar o valor que temos armazenado.

Transients API e Object Cache

Se você leu o post ou assistiu ao vídeo sobre a Transients API do WordPress, a ideia principal aqui não é novidade: um par de chave-valor que evita um processo demorado é exatamente a ideia por trás das duas coisas. De fato, em um certo aspecto elas são a mesma coisa. Veja a implementação da função get_transient:

function get_transient( $transient ) {
    if ( wp_using_ext_object_cache() || wp_installing() ) {
        $value = wp_cache_get( $transient, 'transient' );
    } else {
        ...
    }
    ...
}

Basicamente, se você está usando um mecanismo externo para Object Cache, o transiente será gravado lá. Caso contrário, o banco de dados normal será usado. Interessante, não é? Dá uma olhada lá!

What is an API?

Felipe Elia — Thu, 30 Jun 2022 00:11:49 +0000

Do you know what is an API? Why is it important to use your favorite framework's APIs? Have you already heard about interfaces and black boxes? In this post, we will talk about all these topics with examples.

I was going to write about the reasons why you should use WordPress's APIs but I had to go back to so many concepts that we have to start talking about what is an API. This post is for both junior and senior developers. And yes, we are going to talk about concepts but stay there, these are some important ones.

API is the acronym for Application Programming Interface. But what does that exactly mean?!

"Application" and "programming" are the easy parts. It is the "Interface" that we need to understand better.

What is an Interface?

An Interface is nothing more than the outside layer, the part that connects with the exterior, keeping the interior safe.

We deal with this concept every day and if that wasn't possible we would freak out. Imagine if you had to know all the ins and outs of everything surrounding you! Some interface examples:

Graphical Interface: You click, the program executes. You don't need to know how it does, if you click and it does what you want that is all that matters.
Ordering a meal in a restaurant: You place the order and receive the food. It doesn't matter how many cooks they have, the pan color, or the stove brand.
Sensory System: You don't need to know how your body smells something, it simply does that for you.

Insert a card and a password, and receive the money. That is all that needs to happen. It doesn't matter if it is a machine or a guy with a calculator.

The whole idea is based on the concept of inputs and outputs. Given an input, an output is expected, disregard the implementation:

	Input	Output
Graphical Interface	Button click	Desired action
Restaurant order	Place the order	Receive the food
Sensory System	Touch on skin	Related sensation (cold, heat, etc.)
ATM	Insert a card and password	Receive money

This concept of input-output-no-matter-the-inside we call black box. There is an important difference here:

A black box is what we call something that accepts an input and returns an output, without necessarily revealing how it created the output.
An Interface is how you connect with the system, what is exactly the expected input (a number, two numbers, a string) and how the output will look like (another number, another string). It is like a contract.

Interfaces in OOP

Here I have to open a quick parenthesis. Interfaces are also something very important in Object-Oriented Programming. The idea is exactly the same: if a class declares it implements a certain interface, it is required to implement all the interface's methods. I'll leave here the official PHP documentation about interfaces but leave a comment if this is a topic you would like to see in another post.

Okay... Can we get back to APIs now?

And here is where the real post begins! Let's get back to the acronym:

Application Programming Interface is a part of the application only accessible via code made by a group of methods with inputs and outputs, doesn't matter their implementation.

Does it make more sense now?

(For the complainers, yeah, I know you can access a REST API with your browser but that is not the intended use of it.)

WordPress's APIs

When I had the idea to write this post, I was going to talk about how important it is to use WordPress's internal APIs. WP has lots of these APIs, we've already talked about some of them here (in Portuguese): Transients API and Settings API are some examples. The full list of WordPress's APIs is available at https://developer.wordpress.org/apis/.

But why should we use these APIs instead of simply writing something in the database directly or saving a file in the server?

There are many reasons, let's check some of them.

Note: these concepts are not isolated but rather complementary. Also, I did not try to cover all the possible aspects, so feel free to explore any other aspect in the comments section.

Separation of concerns

This is a principle that aims to split the application into modules, each one responsible for just one thing. These modules communicate with each other using — you guessed it — interfaces. This way, a code that creates a product is apart from the code that deals with orders, and that only calls the module responsible for storing data somewhere.

Many years ago, unfortunately, it was common to see PHP applications with several calls to mysqli_real_connect and similars. Today that is not the reality anymore. In WordPress, for example, we have the wpdb class, other frameworks use ORM but every time it is necessary to store/save some data there is an abstraction layer we can count with.

The Severance TV Series takes separation of concerns to a WHOLE DIFFERENT level.

Readability

We do not write code for machines but for other human beings, after all, we say "Code is poetry" for a reason. That said, it is important to look at a code for the first time and understand what it does.

What is easier to understand? This

<?php
global $wpdb;
$wpdb->query(
    $wpdb->prepare(
        "INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`)
            VALUES (%s, %s, %s)
            ON DUPLICATE KEY
            UPDATE
                `option_name` = VALUES(`option_name`),
                `option_value` = VALUES(`option_value`),
                `autoload` = VALUES(`autoload`)", 
        $option,
        $serialized_value,
        $autoload
    )
);

or this?

<?php
update_option( 'my_option', 'value' );

The second option, right? It is easy to understand we are saving an option and if we want to use any other storage mechanism like Redis or Memcached (more about this below), the part of the software calling the update_option() function does not need to be changed.

Code is Poetry!

Practical Examples

Using WordPress APIs makes life easier. Sometimes, not using them make the project unfeasible.

Files API

This is a classic case. The programmer saves the file using functions like fopen, fclose, etc. and everything works fine. The project grows a bit, infrastructure needs to scale and files start to disappear. Let's give a look at some diagrams to understand it better.

Saving directly into the server (with only one web server)

So far, so good. The admin user sent the file to the single server and, when the user visits the site, the file will be there.

Saving directly into the server (with more than one web server)

Now let's suppose we need another server. In front of the two web servers, we place a load balancer, to split traffic between them.

If we save the file directly into the server, it will be stored only in the server where the admin user uploaded the file, not being found every time the requests are sent to the other web server.

Saving it somewhere else

Usually, the solution relies on saving the files somewhere else, like an Amazon S3 Bucket, for example. It could be anywhere, the important here is to be a place accessible to all the servers.

How do we fix this?

The solution to this example is simple and makes usage of a plugin.

The most important for us here is that the plugin will only work for the code using WordPress's Files API. It will not be able to change direct calls to fopen but only calls to $wp_filesystem->put_contents() or functions that pass through the Files API.

Transients API

If you read the post about the Transients API and the official documentation you'll see that it consists of basically three functions: set_transient(), get_transient(), and delete_transient(). You could quickly implement three functions to store, get, and delete values from the database but you would be losing one of the most used pieces of infrastructure to improve performance: in-memory storage.

Relax, it is not a big deal. When I talked about plugin types, I've talked about drop-ins, one of them being object-cache.php. With it, it is possible to use software like Redis or Memcached to store things in memory, instead of going to the disk every time. Memory access is faster than disk access and, because of that, these programs return things faster than the database.

If you are storing things in your database directly, adding something like these programs to your infrastructure will make no difference. On the other hand, if you are using WordPress's API, a plugin will be enough, it is just a matter of configuring and placing its drop-in and things will automatically work. If you want to change between Redis and Memcached you won't need to worry too, as the implementation will change but the interface you are using remains the same.

Here in the blog, I use the Redis Object Cache plugin

WordPress REST API

I've already talked about this topic years ago but it is still useful. If you got here wanting to learn more about WordPress REST API you can check this other post. I'm pretty sure you will like it!

This is a giant post, I know. If you can share it on your social networks, subscribe to the newsletter, and leave a comment you help me a lot. THANK YOU!

DEV Community: Felipe Elia

Updating my profile on GitHub

Remote work: positions and hiring process

Where to find job opportunities

It is normal not to be called

It is time to send your CV!

But before...

CV: concise and with what will draw attention

Cover Letter

Interviews

Review your equipment: earphones, microphone, and internet connection

Prior preparation is fundamental

Know the company and the job position

If possible, search for the interviewer

An interview is not an interrogatory

Live Coding: think out loud

Conclusion

International Jobs: Does my English need to be perfect?

Does my English need to be perfect?

Nothing replaces a course

Movies, TV shows, games, and code lives

Real life

When I joined the company, I almost gave up!

Tools

Conclusion

WordPress Health Status and the new Report Parser Tool

Asking the same questions over and over again

The Report Parser Tool

WordPress Site Health Info

The Report Format

How to add your own sections to the WordPress Site Health Info page

Status reports in plugins

WooCommerce

Gravity Forms

ElasticPress

Conclusion

FTP No More: Deploying WordPress sites with GitHub Actions

If you are in a hurry... that is fine!

What you need

What the GitHub Action will do

SSH Access

1. Create a pair of SSH keys

2. Authorize the key to connect to your server

3. Test the SSH key (Optional)

GitHub Actions

Workflow name

Secrets for GitHub Action

How to create a secret in GitHub Actions

Triggers and Events

Jobs

Steps

SSH Configuration

Send files with rsync

About exclusions and rsync

Doing more with GitHub Actions

Why you should not use SFTP anymore

Conclusion

Deprecated code in Open Source (with WordPress functions)

Make the change in phases

Semantic Versioning

Practical Example

Version 2.5.0: Implement new code and change the old code without breaking it

Version 3.0.0: Remove the old code

Move deprecated code into separate files

The more you communicate, the better

Changelog

WordPress Functions

Obsolete vs. deprecated

Conclusion

Is labeling Pull Requests messages a good idea?

What is a Pull Request (or Merge Request?)

Prefixes and labels: Agreements about the format

Two highlights: nitpick and praise

Will PHP 7.2 be the minimum required version for WP 6.2?

WordPress and PHP's timeline

What the PHP version changes for WordPress

Return type declarations

Null coalescing operator (??)

Spaceship operator (<=>)

PHP 8 Compatibility and WordPress Versions

Send files with `rsync`

About exclusions and `rsync`