DEV Community: Ion Bazan

Turn a country code into an emoji flag (US ➡️ 🇺🇸)

Ion Bazan — Tue, 21 May 2024 05:38:31 +0000

Flag emojis are a fun and visual way to represent countries and regions. These emojis are part of the Unicode standard and are created using a pair of regional indicator symbols.

In this article, we will explore how to convert 2-letter ISO 3166-1 country codes to flag emojis in Go, PHP and TypeScript.

Understanding Flag Emojis

Flag emojis are composed of two Unicode characters, each representing a regional indicator symbol. For example, the flag of the United States (🇺🇸) is created by placing the Unicode points for the regional indicators "🇺" and "🇸" next to each other.

These Unicode points start at U+1F1E6 (regional indicator symbol letter "A") and continue to U+1F1FF (regional indicator symbol letter "Z").

The formula 🤓

The formula to convert a letter to its corresponding regional indicator symbol is:

Unicode point = <ASCII code of letter> − 65 + 127462

65 is a decimal value of letter "A"
127462 is a decimal value of U+1F1E6

Since 127462 - 65 = 127397 = 0x1F1A5, we will use 0x1F1A5 in further calculations.

Conversion in Go 👨🏻‍💻

Here is an example in Go (Golang) to convert an ISO 3166-1 country code to a flag emoji. This code snippet normalizes the input to uppercase and then converts each character to its corresponding regional indicator symbol. For simplicity, it doesn't perform any validation so you should make sure it is a valid 2-letter code first.

package main

import (
    "fmt"
    "strings"
)

func country2flag(countryCode string) string {
    var flagEmoji strings.Builder
    countryCode = strings.ToUpper(countryCode)
    for _, char := range countryCode {
        flagEmoji.WriteRune(rune(char) + 0x1F1A5)
    }
    return flagEmoji.String()
}

func main() {
    fmt.Println(country2flag("pl"))  // 🇵🇱
    fmt.Println(country2flag("JP"))  // 🇯🇵
    fmt.Println(country2flag("us"))  // 🇺🇸
    fmt.Println(country2flag("EU"))  // 🇪🇺
}

Explanation 👨🏻‍🏫

Normalization: The input country code is converted to uppercase using strings.ToUpper().
String Builder: A strings.Builder is used to efficiently build the resulting flag emoji string.
Character Processing: Each character of the uppercase country code is processed: rune(char) + 0x1F1A5: Converts the character to its corresponding regional indicator symbol by adding 0x1F1A5 (127397).
Appending Characters: The resulting regional indicator symbols are appended to the strings.Builder.
Returning the Result: The String() method of strings.Builder is called to get the final flag emoji string.

Conversion in PHP 🐘

Using preg_replace_callback allows to replace each character in a string using a custom callback:

function country2flag(string $countryCode): string
{
    return preg_replace_callback(
        '/./',
        static fn (array $m) => chr(ord($m[0]) + 0x1F1A5),
        strtoupper($countryCode)
    );
}

echo country2flag('pl'); // 🇵🇱
echo country2flag('JP'); // 🇯🇵
echo country2flag('us'); // 🇺🇸
echo country2flag('EU'); // 🇪🇺

Conversion in TypeScript 😎

This example uses a combination of split and join to process each character individually.

function country2flag(countryCode: string): string {
    return countryCode
        .toUpperCase()
        .split('')
        .map(char => String.fromCodePoint(char.charCodeAt(0) + 0x1F1A5))
        .join('');
}

console.log(country2flag('pl')); // 🇵🇱
console.log(country2flag('JP')); // 🇯🇵
console.log(country2flag('us')); // 🇺🇸
console.log(country2flag('EU')); // 🇪🇺

Conclusion

🤗 Converting ISO 3166-1 country codes to flag emojis can be fun and straightforward in Go, PHP and TypeScript! By understanding how regional indicator symbols work and using simple character manipulation, you can easily generate these emojis programmatically in any other language ✨.

🛠️ Whether you're building a web application or a server-side script, this technique can add a fun and informative visual element to your project.

☝🏻 Please note that the appearance and availability of the flag emojis might vary between systems and locale.

Feel free to post snippets in your favourite programming language in the comments!

This article is based on the snippet I posted on GitHub Gist 3 years ago:

💖 Write Future-Compatible PHP Code with Symfony Polyfills

Ion Bazan — Mon, 20 May 2024 08:53:23 +0000

If you’re like many developers, you know the frustration of being stuck on an older PHP version. Upgrading to the latest and greatest can be a daunting task, especially when you're dealing with legacy code and tight deadlines 🤬. But fear not! Symfony Polyfill is here to save the day, making your life a whole lot easier.

What is Symfony Polyfill? 🤩

In a nutshell, Symfony Polyfill is a collection of PHP functions that replicate features introduced in newer PHP versions, allowing you to use these features even if your server is running an older version of PHP. It's like having a time machine that brings the future to your present codebase ⚡️.

Why Should You Care? 🤔

You might be wondering, "Why should I bother with this polyfill thing?" Well, there are a few great reasons:

Future Compatibility: Writing code that is future-compatible means you won't have to refactor it every time you or your organization decides to upgrade PHP. This saves you countless hours of work and a lot of headaches.
Gradual Migration: If you or your organization is planning to upgrade PHP in the future, Symfony Polyfill allows you to start using newer features now. This makes the transition smoother when the actual upgrade happens.
Community Support: Symfony is a well-established framework with a strong community. By using Symfony Polyfill, you're leveraging code that is robust, well-tested, and supported by many developers worldwide.

Getting Started with Symfony Polyfill 👨🏻‍💻

Integrating Symfony Polyfill into your project is a breeze. Let’s walk through the steps to get you up and running.

First, you need to install the specific Symfony Polyfill package for the PHP version you want to polyfill. For example, to polyfill PHP 8.3 features, run the following command in your project directory:

composer require symfony/polyfill-php83

Use Polyfilled Functions: Now you can start using functions from newer PHP versions even if your current PHP version doesn’t support them. Here’s a simple example:

// Using json_validate() function introduced in PHP 8.3
$json = '{"name": "John", "age": 30, "city": "New York"}';
$isValid = json_validate($json);
echo $isValid ? 'Valid JSON' : 'Invalid JSON'; // Output: Valid JSON

Real-World Benefits 🤓

Imagine you’re stuck on PHP 7.4, but you really want to use some of the cool new features from PHP 8.3, like json_validate(). With Symfony Polyfill, you can start using these functions today.

Here's how it can improve your application's migration process:

💄 Write Modern Code: By using polyfills, you can start writing modern code that adheres to the latest PHP standards. This means when you finally upgrade, your codebase will already be using the latest features.
✨ Reduce Technical Debt: Gradual adoption of new features helps in reducing technical debt. Instead of one massive refactor, you can slowly introduce new PHP features into your codebase.
📜 Enhanced Readability and Maintenance: Modern PHP features often result in more readable and maintainable code. For example, using json_validate() is much clearer than manually writing a complex JSON validation function.

Conclusion 😎

Symfony Polyfill is a powerful tool that can help you write future-compatible code, making your life as a developer much easier. By integrating it into your application, you can take advantage of modern PHP features today, even if you're stuck on an older PHP version.

The best part is, as soon as you migrate your application to a newer PHP version, all usages of polyfills will automatically start using the built-in function implementations provided by the PHP version itself. This makes the migration process smoother and less error-prone, as you don't have to manually refactor your code to remove polyfills.

So, why wait for your organization to catch up? Start using Symfony Polyfill and future-proof your codebase now. Your future self (and your team) will thank you! 🤩

📚 Feel free to dive into the Symfony Polyfill documentation to explore all the features available.

Happy coding!

PS. While using polyfills is incredibly helpful, it's important to remember that upgrading your PHP version as soon as possible is the best long-term solution. Keeping your software up-to-date ensures better performance, security, and access to the latest features.

📊 Change the order Laravel picks up queued jobs (AKA Priority Queues)

Ion Bazan — Mon, 20 May 2024 08:17:22 +0000

Have you ever wished some queued jobs would be processed way ahead others? For example, if you want your VIP client's transanctions to be completed before everyone else's, this article might help you.

Simple approach ✨

If you have only a few tiers of clients, you might want to consider assigning them to a different queue so that VIP clients won't be blocked by other customers:

<?php

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class ProcessJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(private Customer $customer)
    {
        $this->onQueue($this->determineQueue());
    }

    /**
     * Determine which queue to use based on client type.
     */
    private function determineQueue(): string
    {
        return $customer->is_vip ? 'vip' : 'default';
    }

    public function handle(): void
    {
        // Job logic
    }
}

⚙️ Then running separate workers for both queues:

php artisan queue:work --queue=default
php artisan queue:work --queue=vip

✅ This is really easy and will work with any queue driver, like Redis, SQS, Database, etc.

❌ Unfortunately, this is not really scalable if you wish to have more control over the order of queued jobs or have many different tiers of users.

Queue prioritization using custom queue driver 👨🏻‍💻

If you wish to control the order of transactions in more sophisticated way, for example based on a transaction amount or any other factor, consider creating a custom queue driver.

1. Add `priority` column to `jobs` table

To start, add a priority column in your jobs table. You can do this by creating a migration:

php artisan make:migration add_priority_to_jobs_table

Update the migration file:

public function up()
{
    Schema::table('jobs', function (Blueprint $table) {
        $table->unsignedInteger('priority')->default(0); // Default priority is 0
    });
}

public function down()
{
    Schema::table('jobs', function (Blueprint $table) {
        $table->dropColumn('priority');
    });
}

Run the migration:

php artisan migrate

2. Create a Custom Queue Connector

Create a custom queue connector that extends Laravel's database queue connector. In this custom connector, you'll override the push and pop methods to handle job priority:

<?php

namespace App\Queue;

use Illuminate\Queue\DatabaseQueue;
use Illuminate\Contracts\Queue\Job;
use Illuminate\Queue\Jobs\DatabaseJob;
use Illuminate\Queue\Jobs\DatabaseJobRecord;

class PriorityDatabaseQueue extends DatabaseQueue
{
    /**
     * Push a new job onto the queue.
     *
     * @param  string  $queue
     * @param  string  $payload
     * @param  string|null  $queue
     * @return mixed
     */
    public function push($job, $data = '', $queue = null)
    {
        $queue = $this->getQueue($queue);
        $payload = $this->createPayload($job, $queue, $data);

        return $this->database->table($this->table)->insertGetId([
            'queue' => $queue,
            'payload' => $payload,
            'attempts' => 0,
            'reserved' => 0,
            'reserved_at' => null,
            'available_at' => $this->availableAt(),
            'created_at' => $this->currentTime(),
            'priority' => $payload['data']['priority'] ?? 0, // Set the priority
        ]);
    }

    /**
     * Pop the next job off of the queue with prioritization.
     *
     * @param  string|null  $queue
     * @return \Illuminate\Contracts\Queue\Job|null
     */
    public function pop($queue = null)
    {
        $queue = $this->getQueue($queue);

        $job = $this->database->table($this->table)
            ->where('queue', $queue)
            ->where('reserved', 0)
            ->orderBy('priority', 'desc') // Prioritize jobs based on their priority level
            ->orderBy('id', 'asc')
            ->lockForUpdate()
            ->first();

        if (!is_null($job)) {
            return new DatabaseJob(
                $this->container, $this, new DatabaseJobRecord((object) $job)
            );
        }
    }
}

3. Create a Custom Connector Class

Create a custom connector class to register the custom queue connector:

<?php

namespace App\Queue\Connectors;

use Illuminate\Queue\Connectors\DatabaseConnector;
use App\Queue\PriorityDatabaseQueue;

class PriorityDatabaseConnector extends DatabaseConnector
{
    public function connect(array $config)
    {
        return new PriorityDatabaseQueue(
            $this->connections->connection($config['connection'] ?? null),
            $config['table'],
            $config['queue'],
            $config['retry_after'] ?? 60
        );
    }
}

4. Register the Custom Connector

use Illuminate\Support\ServiceProvider;
use App\Queue\Connectors\PriorityDatabaseConnector;

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->resolving('queue', function ($queue) {
            $queue->addConnector('prioritydatabase', function () {
                return new PriorityDatabaseConnector($this->app['db']);
            });
        });
    }
}

From now on, using a prioritydatabase driver will use our custom logic to push and fetch jobs to the queue based on their priority.

5. Configure Queue Connection

Update your config/queue.php to use the new driver:

'connections' => [
    'prioritydatabase' => [
        'driver' => 'prioritydatabase',
        'table' => 'jobs',
        'queue' => 'priority',
        'retry_after' => 60,
    ],
],

6. Set Job Priority When Dispatching Jobs

When dispatching jobs, set the priority level. You can do this by adding a $priority field to the job's payload.

class SomeJob implements ShouldQueue
{
    public function __construct(public int $priority = 0)
    {
    }

    public function handle(): void
    {
        // Job logic
    }
}

// Dispatching the job with priority
$job = new SomeJob(10); // Priority 10
dispatch($job)->onQueue('priority')->onConnection('prioritydatabase');

With these steps, you will have a priority queue setup in Laravel where jobs are stored with a priority column in the jobs table. The custom queue connector ensures that jobs are popped from the queue based on their priority, allowing higher priority jobs to be processed first.

Feel free to customize the way you pop the jobs based on your needs.

✅ More control over the job processing order.
❌ Changing the queue driver requires major refactor to adapt the popping logic. Not all drivers might be supported.

Summary

🕵🏻‍♂️ Digging deep in Laravel queue connectors could be fun and it's interesting to learn how it works internally so that we are able to customize it to our needs.

While the DB driver is easy to understand and customize, I strongly suggest not to use database driver in production. If you wish to maintain scalability and avoid lock issues, I recommend creating a similar connector based on Redis with ZADD and ZRANGE/ZREM to handle similar logic instead.

📫 How to set up custom email domain with iCloud and Cloudflare

Ion Bazan — Mon, 20 May 2024 05:15:48 +0000

As a part of your digital identity, you may want to use a custom domain for your personal email address. In this article I'll show you how to easily set up email receiving and sending without breaking a bank.

Why do I need a custom email domain in the first place?

Most importantly a custom domain keeps you independent from any particular email vendor (e.g. Gmail, Yahoo, etc). You keep your address as long as you keep your domain active and configure your MX records accordingly. Switching to a new vendor is a matter of importing existing emails and changing DNS records.
Let's be honest, it just looks cool to have an email address like firtsname@lastname.com instead of username@gmail.com.
If you are running a small business, it looks more professional and consistent to use your own domain.

OK, how do I do this?

The simplest way to go is to use iCloud+ as it starts at $0.99 but you might be already paying for this if you keep your backups there.

Let's go!

1. Register your domain 🌎

First things first, you'll need to register a domain if you haven't already. You can do this through any domain registrar like GoDaddy, Porkbun, or even Cloudflare itself.

2. Add the domain to iCloud ☁️

You can choose to Add a domain you own or Buy a new domain if you haven't done it yet in the first step.

I suggest using You and other people in the next step to allow your family members to use the same domain for their email addresses. Sharing is caring 🤗.

Click View in Update your domain’s records section to get your DNS settings.

3. Update your DNS records 🛠️

✨ Copy-paste them exactly into your registrar's DNS records dashboard. If you are using Cloudflare, make sure to select DNS Only in Proxy status for the record to work correctly.

4. Finish iCloud setup ✅

After adding all necessary DNS records, give it at least a few minutes (up to 72 hours) to propagate and click Finish setup on the last page.

Once done, you will be able to use your custom email address to send and receive emails straight from your iPhone and Mac.

5. Start receiving (and sending) your emails 💌

To test your changes, try sending an email from your existing email address to the new custom address. If everything went good, you should be able to receive it on your iPhone.

Once you received it, try replying back to make sure sending works well too.

What if I don't use Apple products?

You can try using other email providers:

ZohoMail - $1/mo
Fastmail - $3/mo,
ProtonMail - €3.99/mo,
Many many others...

Note that even if you don't own any Apple product, it could still make sense to get iCloud+ as you can access your emails and files via browser and this option seems to be one of the most affordable and easiest to set up.

What if I want it completely free?

If you don't need to send emails from your custom domain, you can opt in for Cloudflare Email Routing to redirect incoming emails to your existing personal email account (GMail, Yahoo, etc). You won't be able to use this address to send emails, but you can still reply to them with your personal address.

Summary

🚀 That was quick, right? Let me know in the comments if you like it and feel free to share any other services you use to host your emails.

📚 How to see what changed in Composer files

Ion Bazan — Fri, 17 May 2024 18:35:35 +0000

When reviewing a Pull Request that touched composer.json and composer.lock files you might notice that the diffs are usually pretty huge and it's almost impossible to tell what exactly happened there - which packages got added, updated, downgraded or removed? Nobody knows.

That's because Composer stores information about all packages that should be installed in composer.lock together with some of their metadata. This helps to manage the dependencies efficiently and browse most information offline but there is currently no built-in way to compare these files when changed.

How to live with that?

Don't worry, I got you. Simply install Composer-Diff plugin which allows you to easily compare any two versions of your composer.lock files:



composer global req ion-bazan/composer-diff

To run it in your repository:



composer diff # Displays packages changed in current git tree compared with HEAD
composer diff --help # Display detailed usage instructions

By default, it compares current filesystem version with your last committed changes (to use it locally just before committing your new changes):

It produces a colourful, tabulated markdown output which can be copy-pasted into your PR description for reference 🤩

Besides of generating diff for your current filesystem changes, you can compare any 2 git refs or local copies of files using --base and --target options or arguments:



composer diff master # Compare current composer.lock with the one on master branch
composer diff master:composer.lock develop:composer.lock -p # Compare master and develop branches, including platform dependencies
composer diff --no-dev # ignore dev dependencies
composer diff -p # include platform dependencies
composer diff -f json # Output as JSON instead of table

Did I mention it works with all PHP versions from 5.3 all the way till 8.4+?

OK but I'm lazy

Me too! That's why I made things even easier with GitHub Actions - I'm adding Composer Diff Action to all my projects to enjoy an automated report in every PR.

Another day, another useful automation.

OK but I don't like you

No problem, you can check out a few other tools instead:

jbzoo/composer-diff - requires PHP 7.2+, no composer plugin support
josefglatz/composer-diff-plugin - works only right after install/update
davidrjonas/composer-lock-diff - does not work as composer plugin

⚙️ Laravel Queues: Rate-Limiting jobs

Ion Bazan — Fri, 17 May 2024 17:58:10 +0000

Hi guys, today I'd like to talk a bit about rate-limiting Laravel queued jobs 👨🏻‍💻.

This might be a common scenario, where we want to make sure jobs are not processed too fast in order to not overload other system resources.

🤔 In one of my projects there was a case where certain type of jobs had to be processed at specific rate as they had to call a 3rd party API which was rate-limited.

Let's explore different approaches we could take to solve this problem.

1️⃣ Using Laravel's Built-in Rate Limiting

Laravel provides a built-in rate limiting feature that you can use to limit the rate at which jobs are processed.
You can define rate limiters using the RateLimiter::for() method and apply them to your jobs using middleware or directly within your job classes.
Rate limiters can be configured based on various criteria such as the number of attempts per minute, per user, or per resource.

Simply add this to your job class:


    /**
     * The rate limiting middleware for the job.
     */
    public function middleware(): array
    {
        return [
            new \Illuminate\Queue\Middleware\RateLimitedWithRedis('process-job', 10, 60) // Example: 10 jobs per minute
        ];
    }

Pros:

Easy peasy to use and works out of the box.

Cons:

Not for every use case: it marks jobs as failed and drops them if the limiter doesn't have enough quota to process the job at the moment.
This might be useful if the action is triggered too often by an impatient user so some jobs will be dropped but won't work in scenarios where each job must eventually be processed.

2️⃣ Custom Rate Limiting Middleware

If Laravel's built-in rate limiting does not meet your requirements, you can implement custom rate limiting logic within your application thanks to Job Middlewares.
Instead of putting the job back to the queue and decreasing $maxAttempts, you could make the job wait a bit before proceeding to processing it.

Pros:

Quite simple to implement and reusable - you could put it in a trait and use it across several jobs. Cons:
It involve quite a lot of custom logic and is relatively difficult to test.
Time spent waiting for a quota from rate limiting would count towards the job execution time which not always might be desired.

3️⃣ Create a custom Queue Worker

If you are not satisfied with above solutions an you'd like to fetch the job from the queue only when there is quota available in your rate limiter logic, the easiest way to do so is to create a custom Queue Worker:

<?php

namespace App\Queue;

use Illuminate\Queue\Worker;
use Illuminate\Queue\WorkerOptions;

class RateLimitedWorker extends Worker
{
    /**
     * Pop the next job off of the queue with rate limiting.
     *
     * @param  string|null  $connectionName
     * @param  string|null  $queue
     * @param  \Illuminate\Queue\WorkerOptions  $options
     * @return \Illuminate\Contracts\Queue\Job|null
     */
    public function pop($connectionName = null, $queue = null, WorkerOptions $options = null)
    {
        // Implement rate limiting logic here before popping the job
        // For example, use Laravel's rate limiting feature or any custom logic

        return parent::pop($connectionName, $queue, $options);
    }
}

Registering this worker as default application queue worker in your AppServiceProvider will apply this logic to all queues and connections - you can conditionally run the custom logic on certain queues then:

$this->app->extend('queue.worker', function ($worker, $app) {
    return new RateLimitedWorker(
        $app['queue'], 
        $app['events'], 
        $app['queue.failer'], 
        $app['cache.store']
    );
});

The simplest way to rate-limit such jobs is using a sleep() and calculating the number of processes vs allowed limit. More elegant solution would be to use Laravel's RateLimit component. Just make sure you always take into account that there might be many concurrent workers running at any point of time, so use some kind of distributed lock for that. Cheers!

❌ That's a lot of code...

Pros:

Quite easy to implement ✨
Jobs will only be picked up when there is quota available to process them 👍🏻

Cons:

Overriding/extending framework's internal classes might cause problems when upgrading - make sure you got this behaviour covered by tests
Not so elegant solution

4️⃣ Use `Queue::popUsing()`

If you don't want to extend framework's classes, you might want to use composition over inheritance to customize the way your app picks up the jobs from the queue:

<?php

use Illuminate\Support\Facades\Queue;

Queue::popUsing(function ($connection, $queue) {
    // Implement rate limiting logic here before popping the job
    // For example, use Laravel's rate limiting feature or any custom logic

    return Queue::getConnection($connection)->pop($queue);
});

Just put this code in one of your service providers and enjoy avoiding nasty inheritance. Well, that didn't sound right.

Pros:

Elegant,easy to implement and quite flexible solution, without polluting the app with framework internals too much
Jobs will only be picked up when there is quota to process them

Cons:

Quite difficult to test it other than manually running it

😎 Summary

Each option offers flexibility and customization to suit different use cases and requirements. Depending on your specific needs, you can choose the approach that best fits your application architecture and rate limiting requirements.

🤓☝🏻 Actually...

In my case, none of them were good enough.

That's because I looked at it from the wrong angle - the fact that the 3rd party API has some limits shouldn't be the queue's concern but should rather be handled in the SDK or the client class that connects to it and solved there. You might one day call this API directly from a request or CLI and you'd have to rewrite the whole thing all over again.

One way to achieve it is to use Guzzle Rate Limiter Middleware which waits for the quota to replenish before calling the API another time.
Simply plug it wherever you are hitting the external API and boom, job done! 🤘🏻

See you again soon!

Free tools every developer should know 🌝

Ion Bazan — Fri, 17 May 2024 11:22:32 +0000

Hey everyone,

In today's tech-driven world, where subscription-based models reign supreme, the term "freemium" has become commonplace, offering tantalizing glimpses of what could be with just a simple upgrade. Yet, amidst this trend, there's a plethora of services that not only enhance our daily lives but also support our work endeavors.

Today, I'm excited to share my go-to list of tools and services that have been super helpful for me!

TL;DR:

Git repositories + CI/CD: GitHub or GitLab - $0 ✨
Static site hosting: Vercel - $0 ✨
Domain registrar: Cloudflare - $10.18 for .dev domain
DNS and CDN: Cloudflare - $0 ✨
AI completion: ChatGPT + GitHub Copilot - $0 ✨

GitHub

Some of us probably still remember when GitHub used to charge for private repositories and many seeked alternatives at BitBucket or GitLab instead. Since 2019, GitHub offers unlimited private repositories for all developers! This makes it easier to work on some small personal or commercial projects.

What you are getting for free?

Unlimited personal/private repositories
2000 CI/CD minutes per month
500 MB packages storage

Paid plan starts at $4/mo, adding advanced code review tools, and enhanced security features.

You can always upgrade if you need more but it's quite a generous gift for everyone.

GitLab

While personally I prefer GitHub, GitLab mentioned above offers unmatched CI/CD and CVS features and it's all for free and open source! I honestly fell in love with the capabilities of their CI/CD and Docker image hosting a while ago.

Premium plan starts at $29/mo which might be quite pricey comparing to GH.

Vercel

Vercel is a fantastic platform for deploying web projects seamlessly. It offers a simple and intuitive interface, automatic deployments, and integration with popular version control systems like GitHub and GitLab. I'm using it to host my personal website at https://bazan.dev and it rocks 🚀!

Free tier includes:

Unlimited personal projects
Automatic deployments
Preview deployments for feature branches and PRs
Custom domain support

Paid plan starts at $20/mo, offering advanced features like analytics and team collaboration tools (personally I don't need them).

Cloudflare

While Cloudflare for business is quite expensive, their free tier allows you to add basic CDN and firewall functionality to your website.

For $0 you are getting:

Content Delivery Network (CDN): Speeds up website loading times by caching static content on Cloudflare's servers distributed worldwide.
DDoS Protection: Protects websites from Distributed Denial of Service (DDoS) attacks, helping ensure uptime and availability.
SSL/TLS Encryption: Provides HTTPS encryption for secure data transmission between website visitors and servers.
Web Application Firewall (WAF): Guards against common web application vulnerabilities and malicious traffic.
Analytics: Basic analytics and insights into website traffic and performance.

Additionally, Cloudflare offers domains at very competitive prices (my .dev costed me only $10.18 per year).

Paid plan starts at $20/mo with many more features.

ChatGPT

ChatGPT by OpenAI is an AI-powered chatbot that can assist developers in various ways, such as debugging code, generating code snippets, and providing explanations for complex concepts.

Free plan offers a limited number of queries per month but should be enough for personal use.

Paid plan starts at $20/mo and offers access to newer models and faster response times.

GitHub Copilot

Another AI tool, providing AI code completion directly in the IDE of your choice. Amazing pair-programming partner, which helps with repetitive tasks and typos. 🪄

While it's not actually a free subscription ($10/mo), there are many ways to get it for free if you are student, teacher or open-source project maintainer!

Conclusion

The availability of free and affordable services empowers developers to choose the right tools without breaking the bank. Whether you're looking for version control, cloud hosting, or collaboration tools, there's a service out there to meet your needs. Exploring and leveraging these resources can significantly enhance your development process and productivity.

Efficiently resolving composer.lock merge conflicts

Ion Bazan — Wed, 07 Apr 2021 08:32:26 +0000

Efficiently resolving composer.lock git merge conflicts

When working in a team on a PHP project using Composer, you have probably encountered a problem when multiple people added, removed or updated some packages in composer.json and composer.lock on main branch and GIT welcomed you with this message in the morning:

Auto-merging composer.lock
CONFLICT (content): Merge conflict in composer.lock

Resolving such conflict is not a straightforward operation due to the structure of the file which contains all locked dependencies information and a content hash.

In this article I will show you few methods to resolve such conflict and make your life a bit easier.

TL;DR

git checkout --theirs composer.lock
composer update php # the "php" is important here

What not to do?

I’ve seen people doing git checkout --ours composer.lock and pushing the changes… Since it’s overwriting all others’ changes with yours, it’s basically an equivalent of force-pushing changes to main branch — never do that!

Another bad (but not as destructive) idea would be to remove composer.lock file and recreate it using composer update. This might seem like a good idea if you don’t really care about your locked versions and trust your version constraints and tests 100%. In real life, this will most likely introduce some unexpected changes into your feature branch and unnecessarily increase the diff.

Method 1: The fast & simple [my favorite!]

This method is suitable for most common scenarios, when some packages were added or updated in main branch and you are trying to merge it into your feature branch with some other packages added. Assuming there are no dependency conflicts, you are good to go with this solution after merging the composer.json file.

First, accept the changes from base (main) branch:

git checkout --theirs composer.lock

Then, trigger an update of the packages you added or removed:

composer update php

Please note that you may pass any installed (or even not installed) package name to the update command for it to work but passing php will only touch the packages you just added or removed, without unnecessarily updating any extra packages to keep your changes clean.

Pros:

Fast
Simple
Universal — you can use same commands, no matter what packages you add or remove

Cons:

Packages you added on your feature branch will be updated to most recent version matching the constraints (usually it should not be an issue)
Any package updates (via composer update) from your feature branch will be gone — you should re-run the update afterwards if needed

Method 2: Redoing your changes

This method is described in the official Composer documentation. In some cases, when there might be some conflicting packages, it might be better to redo you package additions/removals on top of most recent changes from main branch — similarly as applying changes during a rebase.

First, accept the changes from base (main) branch:

git checkout --theirs composer.lock composer.json

Then, add all the packages you added or removed in your feature branch:

composer require package/a:^1.2
composer require package/b:^2.0
composer remove package/c
...

When you’re done, make sure your composer.json and composer.lock files are valid using composer validate command.

Pros:

Reports conflicting dependencies as you add each of your packages
Quite fast

Cons:

You need to remember which packages you added or removed in your feature branch
Repeating these actions on each merge might be tedious and error-prone
Packages you added on your feature branch will be updated to most recent version matching the constraints (usually it should not be an issue)
Any package updates (via composer update) from your feature branch will be gone — you should re-run the update afterwards if needed

Method 3: Using external tool

Since above methods will not preserve the locked versions on packages that have been added on your feature branch, you may use an external tool such as Composer Git Merge Driver that automates this process, keeping your locked versions and minimizing the diff produced. Please refer to the official repository for installation and usage instructions.

Pros:

Works magically — in most cases you will not even notice the conflict

Cons:

Installation might be a bit too complicated to enforce it in the team

Additional notes

Please keep in mind that using Method 1 or 2 will discard the information about the exact package version added in your feature branch. This is because composer will lock the newest available version matching your constraints at the time of merge. If your package was constrained as ^1.0 and locked at 1.1.0 , it might be updated to 1.2.0 while performing these steps. Most of the time it should not produce any side effects, especially if your version constraints are valid.

DEV Community: Ion Bazan

Turn a country code into an emoji flag (US ➡️ 🇺🇸)

Understanding Flag Emojis

The formula 🤓

Conversion in Go 👨🏻‍💻

Explanation 👨🏻‍🏫

Conversion in PHP 🐘

Conversion in TypeScript 😎

Conclusion

💖 Write Future-Compatible PHP Code with Symfony Polyfills

What is Symfony Polyfill? 🤩

Why Should You Care? 🤔

Getting Started with Symfony Polyfill 👨🏻‍💻

Real-World Benefits 🤓

Conclusion 😎

📊 Change the order Laravel picks up queued jobs (AKA Priority Queues)

Simple approach ✨

Queue prioritization using custom queue driver 👨🏻‍💻

1. Add priority column to jobs table

2. Create a Custom Queue Connector

3. Create a Custom Connector Class

4. Register the Custom Connector

5. Configure Queue Connection

6. Set Job Priority When Dispatching Jobs

Summary

📫 How to set up custom email domain with iCloud and Cloudflare

Why do I need a custom email domain in the first place?

OK, how do I do this?

1. Register your domain 🌎

2. Add the domain to iCloud ☁️

3. Update your DNS records 🛠️

4. Finish iCloud setup ✅

5. Start receiving (and sending) your emails 💌

What if I don't use Apple products?

What if I want it completely free?

Summary

📚 How to see what changed in Composer files

How to live with that?

OK but I'm lazy

OK but I don't like you

⚙️ Laravel Queues: Rate-Limiting jobs

1️⃣ Using Laravel's Built-in Rate Limiting

2️⃣ Custom Rate Limiting Middleware

3️⃣ Create a custom Queue Worker

4️⃣ Use Queue::popUsing()

😎 Summary

🤓☝🏻 Actually...

Free tools every developer should know 🌝

GitHub

GitLab

Vercel

Cloudflare

ChatGPT

GitHub Copilot

Conclusion

Efficiently resolving composer.lock merge conflicts

Efficiently resolving composer.lock git merge conflicts

TL;DR

What not to do?

Method 1: The fast & simple [my favorite!]

Pros:

Cons:

Method 2: Redoing your changes

Pros:

Cons:

Method 3: Using external tool

Pros:

Cons:

Additional notes

1. Add `priority` column to `jobs` table

4️⃣ Use `Queue::popUsing()`