DEV Community: Abdeldjalil

The Developer's Survival Guide: Keeping Your Skills Sharp in an AI World

Abdeldjalil — Mon, 23 Sep 2024 15:09:06 +0000

Hey there,

In today's rapidly evolving tech landscape, developers like us are witnessing a massive shift. AI coding tools are popping up everywhere, offering to generate code with just a few prompts. It's like having a supercharged assistant at our fingertips—sounds fantastic, right?

But let's address the elephant in the room.

While AI tools can boost productivity, over-reliance on them brings significant challenges:

High Costs: Frequent use of AI APIs can lead to hefty bills.
Insecure and Hard-to-Maintain Code: AI-generated code might not follow best practices, leading to security vulnerabilities and maintenance headaches.
Unrealistic Expectations: There's a growing belief that one developer with AI can replace an entire team, piling undue pressure on individuals.
Buggy Software Flooding the Market: Without proper oversight, AI-generated code can result in software riddled with bugs.

But here's the kicker: over-dependence on AI can become our Achilles' heel. If we lose access to these tools—due to costs, outages, or other issues—what then? Coding is a skill that thrives on regular practice. Without it, our problem-solving abilities can fade.

We need to ensure we're leveraging AI as a valuable ally, not becoming dependent on it.

So, how do we keep our minds sharp, stay creative, and continue to think like innovative developers—even when using AI intensively?

Here are some actionable ideas:

Deep Dive into AI-Generated Code

Understand the Code: When AI provides code, take time to read through it.
Ask Questions:
- Why did it generate the code this way?
- Is it secure?
- Did the AI use the right library?
- Is there a simpler way to achieve the same result?
- Does it even need to use a library?
Optimize: Consider how you might improve or streamline the code.

Reflect on Your Work

Self-Evaluate: After completing a task, pause to reflect.
- What did you learn?
- Were there any challenges?
- How can you tackle similar problems more efficiently next time?

Stay Updated with Industry Trends

Continuous Learning: Use downtime to read tech blogs or newsletters.
- What's new in your programming language?
- Are there emerging technologies you should know about?

Participate in Code Reviews

Collaborate: Engage in code reviews to learn from others and share your insights.
Critical Thinking: This practice hones your skills beyond what AI can offer.

Limit AI Use for Certain Tasks

Challenge Yourself: Handle some tasks without AI assistance.
- Start small—debugging code or writing simple functions.
- Gradually tackle more complex challenges.

Question the AI's Choices

Evaluate Suggestions: Don't accept AI solutions blindly.
- Did the AI use the right library?
- Is there a simpler way?
- Is the solution efficient and appropriate?

Read Documentation and Short Articles

Targeted Learning: Focus on documentation and articles relevant to your projects for efficient, immediate application.

By incorporating these practices into your routine, you can keep your developer mind sharp without overwhelming yourself. The goal isn't to shun AI tools—they're valuable assets—but to ensure you're still in control and not letting your skills atrophy.

Remember, the quality of the output depends on the quality of the input. To get the most out of AI, we need to bring our A-game, ensuring we're providing thoughtful prompts and critically evaluating the responses.

Use AI as a powerful tool, not as a crutch. Maintain your skills, stay curious, and keep pushing the boundaries.

In the end, the best developers are those who balance leveraging AI with continuous personal growth. So keep questioning, keep learning, and most importantly, keep coding—not because you have to, but because you love to.

Stay sharp!

P.S. This article was thought up by a human and generated by an AI—proof that when humans and AI team up, we get the best of both worlds (and maybe a few laughs along the way)!

How to Prevent Infinite Loops in `save_post` Hook in WordPress

Abdeldjalil — Fri, 06 Sep 2024 17:58:40 +0000

When you use the save_post hook, you may run into an infinite loop issue. This happens when you try to update the post inside the save_post action, which re-triggers the hook endlessly.

To solve this:

Hook into save_post: Add your custom function to save the post.
Remove the Hook Before Updating: Before calling wp_update_post(), temporarily unhook your function to stop it from firing again.
Re-hook After Update: Once the update is done, reattach the hook.

Final Example:

function your_custom_save_function($post_id) {
    // Ensure this only runs once by unhooking
    remove_action('save_post', 'your_custom_save_function');

    // Update the post without triggering the save_post hook again
    wp_update_post(array(
        'ID' => $post_id,
        'post_title' => 'Updated Title',
    ));

    // Re-hook the save_post action to handle future saves
    add_action('save_post', 'your_custom_save_function');
}

// Hook into save_post
add_action('save_post', 'your_custom_save_function');

This way, you prevent the infinite loop and ensure your updates go through smoothly.

Python Data Structures Demystified: A Friendly Guide to Lists, Tuples, Dicts, Arrays, and Sets

Abdeldjalil — Thu, 22 Aug 2024 11:40:48 +0000

Hey there, Python enthusiasts! 👋 Ever found yourself staring at your code, wondering whether you should use a list, a tuple, or maybe a dictionary? You're not alone! Today, we're going to break down these Python data structures in a way that hopefully makes you go "Aha!" rather than "Huh?". So grab your favorite beverage, and let's dive in!

The Fantastic Five: Meet Your Data Structure Squad

Python gives us a bunch of cool tools to organize our data, but today we're focusing on the fab five: lists, tuples, dictionaries, arrays, and sets. Each one has its own superpowers, and knowing when to use which can make your code faster, cleaner, and just plain better.

1. Lists: The Swiss Army Knife 🔪

Lists are like that one friend who's always up for anything. Need to store a bunch of items and maybe change them later? Lists have got your back.

shopping_list = ['apples', 'bananas', 'chocolate']
shopping_list.append('coffee')  # Because, priorities!

When to use:

You need a flexible, ordered collection of items
Your data might change (add/remove items)
You want to do list-y things like sorting or reversing

Pro tip: Lists are great for most cases, but they can be memory-hungry with large datasets.

2. Tuples: The Reliable Ones 🏋️‍♀️

Think of tuples as lists that hit the gym and got super strong. They're immutable, meaning once you create them, they're set in stone.

coordinates = (33.9416, -118.4085)  # LAX airport coordinates

When to use:

You have data that shouldn't change (like coordinates)
You're returning multiple values from a function
You need a slightly more memory-efficient version of a list

Fun fact: Because tuples are immutable, they can be used as dictionary keys. Try that with a list, and Python will give you the side-eye.

3. Dictionaries: The Librarians 📚

Dictionaries are like the smart librarians of the Python world. They organize information by keys, making it super fast to find what you need.

book = {
    'title': 'The Hitchhikers Guide to the Galaxy',
    'author': 'Douglas Adams',
    'answer_to_everything': 42
}

When to use:

You need fast lookups by a unique key
You're working with JSON-like data
You want to associate values with keys (like a real dictionary!)

Cool trick: As of Python 3.7, dictionaries remember the order you put things in. It's like they got a memory upgrade!

4. Arrays: The Specialized Athletes 🏃‍♂️

Arrays are like lists that decided to focus on one type of data and get really good at it. They're not used as often in everyday Python, but they shine in specific scenarios.

import array
numbers = array.array('i', [1, 2, 3, 4, 5])  # An array of integers

When to use:

You're dealing with large amounts of numeric data
Memory efficiency is crucial
You're doing lots of math operations (especially with NumPy arrays)

Heads up: For most Python tasks, you'll probably stick with lists. But when you need that extra performance boost for number crunching, arrays (especially NumPy arrays) are your best friends.

5. Sets: The Unique Snowflakes ❄️

Sets are like lists that hate duplicates. They're perfect when you need to ensure each item only appears once.

unique_visitors = {'alice', 'bob', 'charlie', 'alice'}  # Alice only counted once!
print(unique_visitors)  # Output: {'bob', 'alice', 'charlie'}

When to use:

You need to eliminate duplicates from a collection
You're doing set operations (union, intersection, etc.)
You want to quickly check if an item exists in a collection

Cool feature: Set operations in Python are super intuitive. Need items that are in both set A and set B? Just do A & B. Mind blown! 🤯

Choosing Your Data Structure: A Quick Guide

Still not sure which to use? Here's a quick decision tree:

Need to maintain order and modify contents? → List
Have fixed data that won't change? → Tuple
Want fast lookups by a unique key? → Dictionary
Dealing with lots of numeric data and need performance? → Array (consider NumPy)
Need a collection of unique items? → Set

Wrapping Up

There you have it, folks! A whirlwind tour of Python's fantastic five data structures. Remember, there's no one-size-fits-all solution. The best data structure depends on your specific needs, the operations you'll perform most often, and sometimes just personal preference.

The more you work with these structures, the more intuitive your choices will become. So go forth and structure your data like a pro! And remember, in the wise words of the Python zen: "There should be one-- and preferably only one --obvious way to do it."

Happy coding, Pythonistas! 🐍✨

A Simple Guide to Developing AJAX-Driven Plugins for WordPress

Abdeldjalil — Sun, 04 Feb 2024 22:02:51 +0000

Introduction

In this comprehensive guide, we will explore how to develop AJAX-driven plugins for WordPress, covering everything from setting up the basic structure to securing AJAX requests and adding custom admin menus.

Plugin Structure and Setup

To get started, let's take a look at the overall structure of our plugin. We will follow best practices by organizing our code within a namespace and creating a class to encapsulate all functionality. Here's what the initial setup might look like:

<?php
/*
Plugin Name: WP AJAX Plugin
Description: A simple AJAX example for WordPress.
Version: 1.0
Author: Your Name here
Text Domain: wp-ajax-plugin
*/

namespace MyAjaxPlugin;

// Prevent direct access
defined('ABSPATH') or die('No script kiddies please!');

class MyAjaxPlugin {
    // ...
}

new MyAjaxPlugin();
?>

This code sets up the basic plugin structure, including the necessary PHP comments for proper identification and activation of the plugin.

Enqueuing Scripts

Now that we have our plugin set up, let's enqueue the necessary scripts for our AJAX-driven plugin. To do this, we will use the add_action('admin_enqueue_scripts', ...) hook to register our JavaScript file and localize variables for use in our JavaScript code. Here's an example of how to enqueue a script:

public function adminScripts($hook) {
    if ('toplevel_page_my-ajax-plugin' !== $hook) {
        return;
    }

    wp_enqueue_script('my-ajax-request', plugin_dir_url(__FILE__) . 'js/ajax-script.js', ['jquery'], false, true);
    wp_localize_script('my-ajax-request', 'MyAjax', ['ajaxurl' => admin_url('admin-ajax.php')]);
}

The adminScripts method checks whether the current hook matches our plugin's top-level page. If it does, it enqueues the my-ajax-request script and localizes the ajaxurl variable for use in our JavaScript code.

Localizing JavaScript

Localization is crucial for ensuring that our plugin works correctly across different languages and environments. By using the wp_localize_script function, we can pass data from PHP to JavaScript while preserving any existing translations. For example:

var myAjaxRequest = {
    url: MyAjax.ajaxurl,
    nonce: MyAjax.nonce
};

In this case, we're passing the ajaxurl and nonce values from our PHP code to our JavaScript code, allowing us to make secure AJAX requests.

Secure AJAX Handling

When working with AJAX in WordPress, security should always be a priority. One way to ensure secure communication between the server and client is by using nonces. Nonces help protect against cross-site request forgery attacks by verifying that the request was initiated by an authorized source. Here's an example of how to handle AJAX requests securely:

if (wp_verify_nonce($_POST['nonce'], 'my-ajax-nonce')) {
    // Process the request
} else {
    // Invalid nonce, reject the request
}

By checking the validity of the nonce before processing the request, we can prevent unauthorized actions and maintain the security of our plugin.

Adding Admin Menu

Adding a custom admin menu to our plugin is straightforward thanks to the add_menu_page function. This function takes several arguments, including the page title, menu title, capability, menu slug, callback function, and icon URL. Here's an example of how to add a custom admin menu:

function adminMenu() {
    add_menu_page(
        esc_html__('My AJAX Plugin Settings', 'my-ajax-plugin'), // Page title
        esc_html__('My AJAX Plugin', 'my-ajax-plugin'), // Menu title
        'manage_options', // Capability
        'my-ajax-plugin', // Menu slug
        [$this, 'settingsPage'], // Function to display the settings page
        'dashicons-admin-generic' // Icon URL
    );
}

This code adds a new top-level menu item called "My AJAX Plugin" with a submenu titled "My AJAX Plugin Settings". It also specifies the appropriate capabilities and icon for the menu.

Displaying Plugin Page

Once we have added the admin menu, we need to create the actual settings page for our plugin. This involves creating an HTML form where users can input their desired text and submit it via AJAX. Here's an example of how to display the plugin page:

function settingsPage() {
    ?>
    <div class="wrap">
        <h2><?php esc_html_e('My AJAX Plugin', 'my-ajax-plugin'); ?></h2>
        <form id="my-ajax-form">
            <label for="name"><?php esc_html_e('Enter your name:', 'my-ajax-plugin'); ?></label>
            <input type="text" name="name" id="name" required>
            <input type="hidden" name="nonce" id="my_nonce" value="<?php echo wp_create_nonce('my-ajax-nonce'); ?>">
            <button id="submit-name"><?php esc_html_e('Submit', 'my-ajax-plugin'); ?></button>
        </form>
        <div id="message"></div>
    </div>
    <?php
}

This code creates a simple form with an input field for the user's name and a hidden nonce field. When the user submits the form, the AJAX request will be sent to update the "message" div with a success message.

Conclusion

In conclusion, By understanding the various aspects involved, such as plugin structure, script enqueuing, localization, secure AJAX handling, and custom admin menus, we can create powerful and engaging experiences for our users.
Keep in mind that this code is not intended to be used on production.

The complete code is on this Github repository

The Ultimate Guide to Effortless PostgreSQL Database Backups

Abdeldjalil — Sat, 03 Feb 2024 18:31:04 +0000

Welcome to the ultimate guide on how to easily back up your PostgreSQL database. Whether you're a novice or an experienced web developer, this comprehensive guide will walk you through the process step by step. We'll be using two essential commands: pg_dump for creating backups and pg_restore for restoring them. So, let's dive in!
Why Back Up Your PostgreSQL Database?

Before we get started with the commands, it's important to understand the importance of database backups. Imagine you've spent countless hours developing your web application, and suddenly, disaster strikes. Your database gets corrupted, or crucial data is accidentally deleted. Without a backup, you could be facing a nightmare scenario.

That's where PostgreSQL's pg_dump and pg_restore commands come to the rescue. They allow you to create backups and restore your database to a previous state, ensuring the integrity of your data and the peace of mind every developer deserves.
Backing Up Your PostgreSQL Database with pg_dump

The pg_dump command is your go-to tool for creating a backup of a PostgreSQL database. Let's break down the command:
bash

pg_dump -h 127.0.0.1 -U myUserName --format custom --clean --no-owner --no-privileges -d my_database_name > /..destination../full_db_backup.sql

Here's what each part of the command does:

-h 127.0.0.1: Specifies the hostname of your PostgreSQL server.
-U myUserName: Sets the username for accessing the database.
--format custom: Chooses the custom format for the backup.
--clean: Includes SQL commands to drop existing objects before recreating them.
--no-owner: Prevents the backup file from specifying the owner, making it usable in different configurations.
--no-privileges: Omits SQL commands for granting or revoking privileges, it will help in moving the db to a new server hasslefree.

The backup file will be saved at /..destination../full_db_backup.sql. With this command, you've successfully created a backup of your "my_database_name" database.
Restoring Your PostgreSQL Database with pg_restore

Now that you have your backup, it's essential to know how to restore it using the pg_restore command. Here's the command:

pg_restore -h 127.0.0.1 -U myOtherDbUsername -W --no-owner --no-privileges -d my_new_database_name path/full_db_backup.sql

Here's what's happening:

-h 127.0.0.1: Specifies the hostname of the local PostgreSQL server.
-U myOtherDbUsername: Sets the username for accessing the database.
-W: Prompts for a password to ensure security.
--no-owner: Skips specifying ownership, allowing you to use the backup on different configurations.
--no-privileges: Omits privilege-related SQL commands.

The command will restore your backup file located at path/full_db_backup.sql into the "my_new_database_name" database on your local server.
Understanding --clean, --no-owner, and --no-privileges

These three options are essential for ensuring the versatility of your backup file:

--clean: Adds SQL commands to drop existing objects before recreating them, ensuring a clean restoration.
--no-owner: Avoids specifying ownership, making the backup usable in various setups.
--no-privileges: Excludes privilege-related SQL commands, allowing flexibility when restoring.

Conclusion

With the power of pg_dump and pg_restore at your fingertips, you can effortlessly create and restore backups of PostgreSQL databases. These commands provide a convenient way to safeguard your database's integrity and recover swiftly from any unexpected mishaps. So, go ahead and put this knowledge into action to ensure the security and reliability of your PostgreSQL database! Happy coding!

Navigating the Depths of Log Analysis: Unleashing the Power of Lnav

Abdeldjalil — Sun, 17 Sep 2023 03:56:22 +0000

Introduction

Navigating through log files can be quite cumbersome, particularly when you're unsure about what you're looking for. However, with the appropriate tools at your disposal, this process can become significantly more manageable. Before discovering Lnav, I relied on a variety of tools and a series of piped commands to extract the information I needed from logs. Lnav, on the other hand, is an all-encompassing tool that simplifies log navigation and greatly enhances efficiency.

How to use Lnav:

Start Lnav:

To begin using Lnav, open your terminal and run the following command, replacing logfile.log with the path to your log file:

lnav logfile.log

Basic Navigation:

Once you have your log file open in Lnav, you can navigate through the log entries using the following keys:

j and k or arrow keys: Move up and down through the log entries.
Ctrl-u and Ctrl-d: Scroll up and down one page at a time.
g: Go to the beginning of the log file.
G: Go to the end of the log file.
:q : To quit Lnav, yes the same way you quit Vim.

Goto:

The goto command in Lnav allows you to navigate log entries based on timestamps or line numbers.
Running goto is similar to running a command within Vim, where you essentially use '':'' followed by goto.

Let's jump to the examples:

1. Jump to a Specific Timestamp:

:goto 2023-09-15 15:30:00

2. Navigate Relative to the Current Time:

:goto 1 hour ago

:goto 2 days ago

These relative time expressions are helpful for quickly reviewing recent log entries or identifying issues that occurred in the past.

3. Go to a Specific Line Number:

:goto 5000

4. Find the First or Last Log Entry:

:goto first

:goto last

5. The Offset Keyword:
You can also use the offset keyword with the goto command to move forward or backward by a specific number of log entries. For example:

To move forward by 100 log entries:

:goto offset 100

To move backward by 50 log entries:

:goto offset -50

Searching and Filtering:

Lnav's search and filtering capabilities help you find specific log entries quickly:

/: Start a text search. For example, /error will highlight all lines containing the word "error."
n and N: Move to the next and previous search results.
:filter-in: can be used the same way as a regular search, matches are highlighted in green in the text view.

:filter-in 404

Conclusion:

In conclusion, Lnav's user-friendly interface, coupled with its rich feature set, positions it as an invaluable tool for log analysis and management. Whether you're an experienced system administrator or a developer seeking to streamline log-related tasks, Lnav's versatility and efficiency make it an essential addition to your toolkit.

To learn more about Lnav

Comparison of npm, Yarn, pnpm, and npx.

Abdeldjalil — Sat, 02 Sep 2023 10:33:25 +0000

The Node.js ecosystem is a rapidly evolving realm filled with a plethora of tools and technologies. For developers, keeping pace with these innovations can be a formidable challenge. Personally, I struggle to remember the differences between each package manager.

In this article, we'll delve into the distinctions between npm, Yarn, pnpm, and npx, helping you understand the differences between each tool.

Package Manager Comparison

npm

Package Manager Type: npm is primarily a package manager used for installing and managing JavaScript packages (dependencies) in your Node.js projects.
Dependency Management: It handles dependencies defined in your project's package.json file and installs them in the node_modules directory.
Scripts: npm also allows you to define and run scripts in your package.json file, making it a build tool to some extent.
Global Packages: You can install packages globally using the -g flag, making them available for command-line use.
Lock File: npm uses a package-lock.json (or npm-shrinkwrap.json in older versions) for dependency locking.
Parallel Installations: It installs packages sequentially by default.
Disk Space Efficiency: npm creates a separate copy of each package in the node_modules directory for each project, which can lead to high disk space usage.
Community and Ecosystem: npm has a large and established community with a vast ecosystem of packages.

Yarn

Package Manager Type: Yarn is another package manager like npm, designed to be faster and more reliable in terms of dependency resolution and installation.
Dependency Management: It handles dependencies defined in your project's package.json file and installs them in the node_modules directory.
Scripts: Yarn allows you to define and run scripts in your package.json file, similar to npm.
Global Packages: You can install packages globally using the global flag, similar to npm.
Lock File: Yarn uses a yarn.lock file for deterministic dependency resolution.
Parallel Installations: Yarn introduced parallel installation by default, making it faster than npm.
Disk Space Efficiency: Yarn stores packages in a global cache and links them to projects, reducing disk space usage compared to npm.
Community and Ecosystem: Yarn gained popularity quickly due to its speed improvements and has a strong community.

pnpm

Package Manager Type: pnpm is a package manager like npm and Yarn but with a unique approach to dependency management.
Dependency Management: pnpm installs packages concurrently, which can result in faster installations compared to npm (sequential) and is similar to Yarn.
Scripts: It does not have a concept of global installations.
Global Packages: no global installations.
Lock File: pnpm uses a pnpm-lock.yaml file for dependency locking.
Parallel Installations: pnpm installs packages concurrently, similar to Yarn.
Disk Space Efficiency: pnpm uses a hard-linking mechanism that allows multiple projects to share the same package dependencies without duplicating them, significantly reducing disk space usage.
Community and Ecosystem: pnpm has a smaller but growing community, particularly among projects looking to save disk space and improve installation speed.

npx

Utility Type: npx is a utility for executing Node.js packages (usually binaries) that aren't globally installed on your system.
Usage: It helps resolve the correct command to execute from the local project's node_modules or from the global npm/yarn installations.
Global Packages: npx is not used for global installations but for running commands from local or global packages.
Note: It is not primarily a package manager but a tool for executing package binaries.

Summary:

Here are the main differences:

npm: A traditional package manager with a focus on dependency management and script execution.
Yarn: Similar to npm but with a focus on faster and deterministic installations, as well as workspace support.
pnpm: A package manager that installs packages concurrently and efficiently manages disk space through hard-linking, making it faster and more space-efficient compared to npm and Yarn.
npx: A command-line utility for running binaries or scripts from Node.js packages without the need for global installations. It is not primarily a package manager but a tool for executing package binaries.

How to use Systemd Timers to Schedule the Execution of a Specific Command

Abdeldjalil — Sat, 31 Dec 2022 19:09:58 +0000

If you need to run a command periodically on your Linux server, you might consider using a Systemd timer instead of a cron job. Systemd timers offer more control over your command and are more flexible than Cron jobs.
Here's a quick comparison between the two:

Systemd timers are more flexible than Cronjobs. They allow you to specify more granular time intervals, such as "every 15 minutes" or "every other hour on weekdays." They also allow you to specify more complex schedules, such as "every Monday, Wednesday, and Friday at 10am."
Systemd timers are easier to manage. You can use the systemctl command to start, stop, enable, disable, and view the status of Systemd timers. This is much more convenient than having to manually edit Cronjob configuration files.
Systemd timers offer better integration with the rest of the system. They can be used to trigger system-wide events, such as triggering a system shutdown or reboot. They can also be used to trigger custom targets, which are collections of units (such as services, sockets, and paths) that can be started, stopped, or restarted as a group.
Systemd timers can be used to trigger actions based on system state. For example, you can use a timer to trigger a script that checks for low disk space and takes action to free up space if necessary.
Systemd timers are more reliable than Cronjobs. Systemd is a modern and reliable init system that is used by default in most modern Linux distributions. In contrast, Cron has a long history of security vulnerabilities and can be prone to errors. By using Systemd timers, you can take advantage of the reliability and security benefits of Systemd.

As an example, let's update Algolia indexes for Magento products using the default Magento command, we will need to create two files: a Systemd unit file and a Systemd timer file.

The unit file will contain the configuration for the service that will be run to update the Algolia indexes. This will include details such as the command to be run, the working directory, and any dependencies or requirements for the service.

The timer file will contain the configuration for the timer that will control how often the service is run. This will include details such as the time interval between runs, as well as any special scheduling considerations (e.g. only running the service on certain days of the week).

Once these two files are created, we can use the systemctl command to start, stop, enable, and disable the timer as needed. This will allow us to easily automate the process of updating the Algolia indexes for our Magento products.

Let's first create the Systemd unit file on /etc/systemd/system/update-products-indexes.service

The content of update-products-indexes.service

[Unit]
Description=Update indexes
Requires=nginx.service
After=nginx.service

[Service]
Type=oneshot
WorkingDirectory=/var/www/magento-website/current
ExecStart=/usr/bin/php bin/magento indexer:reindex

[Install]
WantedBy=multi-user.target

There are a few things to note in the following configuration:

The Type=oneshot parameter specifies that the service should only be run once, and not kept alive.
The WorkingDirectory parameter specifies the directory in which the command will be run. In this case, it will be inside the Magento installation located at /var/www/magento-website/current.
The ExecStart parameter specifies the command to be run, which comes with the Magento installation.

For more information, you can refer to the official documentation.

Next we will create the timer file and save it on /etc/systemd/system/update-products-indexes.timer

The content of update-products-indexes.timer

[Unit]
Description=Timer for products indexes update
Requires=update-products-indexes.service

[Timer]
Unit=update-products-indexes.service

# Time to wait after booting before we run first time
OnBootSec=10min

# Define a calendar event (see `man systemd.time`)
OnCalendar=0/6:00:00

[Install]
WantedBy=multi-user.target

To tell Systemd to run our configured service, we need to start the corresponding timer with the following command:

sudo systemctl start update-products-indexes.timer

To ensure that the service is run at boot time in case the server is restarted, we need to enable both the service and the timer with these commands:

sudo systemctl enable update-products-indexes.service
sudo systemctl enable update-products-indexes.timer

It's important to note that we only need to start the timer file, as it will call the unit file (service) at the specified frequency.
However, if you want to run the unit file directly, you can use the following command:

`sudo systemctl start update-products-indexes.service`

In conclusion, using Systemd timers can be a powerful and convenient way to automate the execution of a specific command on a Linux server. They offer greater flexibility and ease of management compared to cron jobs, and provide better integration with the rest of the system. Whether you need to run a command periodically or based on system state, Systemd timers can help you get the job done efficiently and reliably. So next time you need to automate a task on your Linux server, consider using Systemd timers as an alternative to cron jobs.

Figma plugin project setup using Figsvelte boilerplate

Abdeldjalil — Thu, 16 Dec 2021 01:21:49 +0000

Introduction

I always find working with Javascript framework on a Figma plugin project to be at a certain point an over-engineering choice that brings more maintenance cost without a real added value, at least from my point of view, at the same time it also brings a lot of ready to use features that make using it in a project appealing but still the tradeoffs were against it, yes I used the past because I think differently now, after discovering Svelte the tradeoffs turned in favor of using Javascript framework without sacrificing simplicity.

Install Figsvel

Start by installing Figsvel boilerplate as so:

npx degit thomas-lowry/figsvelte figma-plugin
cd figma-plugin
npm install

Update dependencies

Even though you can work on your Figma plugin without updating dependencies I prefer to update it, so if you're the same this is how it's done.

1- Installing npm-check-updates with npm i -g npm-check-updates

2- Inside your project folder run ncu --upgrade

3- Before updating our node_modules with the new dependencies let's do one more thing, replace rollup-plugin-typescript with @rollup/plugin-typescript.

4- Just to make sure no strange error emerge remove node_modules directory and run npm install

Done

Update manifest.json

Lastly update public/manifest.json that the current version in Figsvelte repo lack a config update needed by Figma to run correctly the plugin which is: "editorType": ["figma"]

You can learn more about it in the Figma plugin doc.

Conclusion

Congratulation, you're good to go for your next Figma plugin with Svelte framework without sacrificing the simplicity of JavaScript nor the advanced features a Framework can bring.