What’s more interesting is that the recipient address is not mine. Yet, it lands in my mail.

Funny how they thought we would have flying cars in 2020, but it’s 2025 and this is the best some people can use tech for.

If you've been programming for any reasonable length of time, there's no doubt you've already discovered the secret "KFC recipe" of programming. It's a secret, which when you have learned it, can potentially turn you into a millionaire! Finally, you get to buy your dream car with a customized number plate and cruise on a billion-dollar yacht, sipping champagne, flying to exotic locations and eating at the fanciest restau------ oh wait... you don't know the secret? Bummer.🤦🏽‍♂️

My bad. This secret does come by experience, but in this article, we will give it to you for free. This trick I'm about to show you is really simple but I assure you that it works.

The trick is to master keyboard shortcuts.

The time taken to find your way around a GUI and move the cursor to the right position can always quickly be cut in half or reduced by as much as 90% (just an estimate...). This advice may sound simple and probably like a no-brainer, but I'll give an example to fortify the point I'm making.

It wasn't until I started using Ctrl + backspace (equivalent is Cmd + backspace) to clear unwanted words that I realized how much time was being wasted just by simply using backspace on its own.

This is how much time it takes when using backspace on its own:

Compare that to this:

The former takes about 33.19 seconds while the latter takes just under 5.85 seconds!

Even better, using Ctrl + A followed by backspace or delete takes an astonishing 1.63 seconds. You could even speed it up a bit more by first selecting the entire passage with the mouse and pressing backspace or delete. This takes about 1.51 seconds. Obviously, the only reason the GUI method worked the fastest in this example is because the text was not too lengthy. Bulk up the text and the method may slow down exponentially, as compared to using Ctrl + A, which has a time complexity of O(1).

This is, of course, just a rough demonstration but in the real world, these things really do add up and cost you a LOT of time.

I have been complimented by a former coworker about how fast I type. And yet I don't even think I type that fast.

In summary, learning how to use keyboard shortcuts is a secret recipe you must know as a software developer. It will absolutely transform the way you write code.

In the last post, I mentioned something about being able to trigger desktop notifications right from your NativePHP app. Today, I wish to test it out and see if it'll be easy to do.

Getting the application set up took quite a while, and I had to dig through the Github issues of the repository in order to find a way to get the app running. Clearly, there is still a lot of work to be done in order to make the set up as smooth and seamless for as many platforms as possible.

For that reason, I will not show how to set up the app at this time. But if you have any issues, do well to consult the repository.

TLDR: I just need the code

If you're not interested in reading the full article here, you can find the necessary code in this commit.

Running the app

To get Electron to open up, we just need to build and then run.

So I did php artisan native:build win to build.

And then php artisan native:serve to start the server.

What this did was to open up a native Electron window.

By default, it opened up my DevTools as well. We'll just go ahead and close that.

Modifying UI

Now we need to add a button that we can click to show the notifications. Since we're working in Laravel, we already have a welcome.blade.php view by default. And the 4 items that appear are actually all just buttons, so we'll just duplicate them.

<div class="mt-16">
    <div class="grid grid-cols-1 md:grid-cols-2 gap-6 lg:gap-8">
        <button id="runButton" class="scale-100 p-6 bg-white dark:bg-gray-800/50 dark:bg-gradient-to-bl from-gray-700/50 via-transparent dark:ring-1 dark:ring-inset dark:ring-white/5 rounded-lg shadow-2xl shadow-gray-500/20 dark:shadow-none flex motion-safe:hover:scale-[1.01] transition-all duration-250 focus:outline focus:outline-2 focus:outline-red-500">
            <h2 class="text-xl font-semibold text-gray-900 dark:text-white">Show notification</h2>
        </button>

        ...

</div>

And then when we run it, we get:

Certainly not the best UI, but just a proof of concept.

Now we want that button to do something when clicked, so we already gave it an ID of runButton. We'll create a script on this same welcome page that sends a POST request to the appropriate controller which will then invoke the notification.

So before our closing body tag, we can create a script like so:

<script>
    document.getElementById('runButton').addEventListener('click', function() {
        // Send an AJAX request to the route
        fetch("{{ route('run.method') }}", {
            method: 'POST',
            headers: {
                'X-CSRF-TOKEN': '{{ csrf_token() }}',
                'Content-Type': 'application/json',
            },
        })
        .then(data => {
            // Handle the response or update the UI as needed
        })
        .catch(error => {
            console.error('An error occurred:', error);
        });
    });
</script>

The main takeaway from this script is the fetch() method which sends a POST request to the server. We have not yet defined the target endpoint, so let's do that.

Endpoint and Controller

Before we add the endpoint to the default routes in web.php, let's go ahead and create the controller.

With Artisan, it's pretty easy to generate. Since we don't need multiple methods, the simplest thing here is to use the shortcut flag to generate an invokable controller:

php artisan make:controller -i NotificationButtonController

Then in the controller, we can just modify the __invoke class as follows:

public function __invoke()
{
    Notification::title('Hello from NativePHP')
        ->message('This is a detail message coming from your Laravel app.')
        ->show();
}

This example was actually lifted straight out of the documentation.

Now we can link this controller in our web.php routes:

<?php

use App\Http\Controllers\NotificationButtonController;
use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| Web Routes
|--------------------------------------------------------------------------
|
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider and all of them will
| be assigned to the "web" middleware group. Make something great!
|
*/

Route::get('/', function () {
    return view('welcome');
});

Route::post('/run-method', NotificationButtonController::class)->name('run.method');

Testing the code

Now we can just refresh the Electron window (using the relevant keyboard shortcut) and then click the button. It will gracefully display a native notification!

Conclusion

I hope you can see how easy it was!

What is NativePHP?

If you've ever needed a way to build desktop apps, you may find that you often need to serve a backend and link it up with an Electron.js app. However, with NativePHP, you can build your functionalities using PHP. In other words, you can build your Electron desktop application using PHP.

As we speak, much work has already been done on the framework, but it is heavily dependent on Laravel, so you need to know some Laravel.

The framework is still in alpha, so don't expect too much at this point.

What we'll learn

I'm no pro when it comes to NativePHP. In fact, I'm writing these as I'm learning it too. I neither have prior experience with it nor have I watched any tutorials about it. But it is my goal to power through the entire documentation and note down what I'm learning. I wish to help boost the publicity of this exciting new framework.

Some of the features currently described in the docs include:

• Sending notifications

• Configuring hotkeys

• Reading from the clipboard

• Popping up dialogs

• Working with application windows

...and so much more!

I think the possibilities are endless, and the fact that I can build all these in PHP is frankly awesome.

Final words

I have a ton of work and this series will be updated in my leisure time. However, you can follow my page for more updates coming soon.

But what happens when the biggest social messaging app in your community fails at one of these? Serious consequences arise.

In my case, information failed to be available when I needed it which led to serious data loss. This post is not a post of praise for WhatsApp. It's a post born out of frustration.

The problem with WhatsApp

When WhatsApp launched in November 2009, I do not believe they had scalability in mind. Perhaps, they thought they would only have a few users across their country. Things, of course, changed for them when Facebook went ahead to purchase WhatsApp in 2014 for $19 billion. I still remember it like it was yesterday.

I have used WhatsApp for several years and observed its steady growth and rollout of features. Regardless, the cracks in their architecture were showing up from time to time. Many times, they took several months to roll out features that were already present in Telegram. Even when they finally allowed WhatsApp to be used on laptops, it still needed to be in sync with the mobile version and wouldn't work when the phone was offline or off. It took a few more years of development until we finally got to a point where we could use it on multiple devices simultaneously.

However, even with the ability to use WhatsApp on multiple devices, uninstalling WhatsApp on your phone would terminate the connection to the PC apps. So then I ask: what is the problem?

From my analysis, the problem is that WhatsApp, from the start, was designed to store user messages on their mobile devices rather than on the cloud. The only thing being stored in the cloud were probably undelivered messages and files that could only be retained for a couple of weeks.

Sure, I get it. They were losing money before Facebook came in to purchase them. That would mean that they couldn't possibly afford to keep trillions of messages on their servers, especially when the app itself was already free and devoid of advertisement. The sensible thing, therefore, was to let users keep track of those messages and then store backups of the conversation history.

Now this is where things get really dicey. As the years rolled on, I personally began to record database sizes of 1.3 GB upwards.

If you'd like to see how much space your WhatsApp backups are consuming, on Android, go to Internal Storage>Android>com.whatsapp>databases

To add to that, WhatsApp keeps backups of up to 7 days. 1.3 GB multiplied by 7? Approximately 8.45GB!

Add the media files, which in my case, were up to 23 GB and we now have 31.45 GB! Squish this into a 64GB phone with several other apps and you can see the problem. The price difference between a 64GB phone and a 128GB phone is not a cup of coffee.

Meanwhile, my Telegram account, which I've actively used since 2015 or 2016 doesn't even hold a single KB in user data.

Remember, I'm here to rant, not to make excuses for them.

What went wrong on my phone?

Till date I have no idea. I had enough space in my phone.

I was headed to an event on Tuesday, July 18, and as soon as I arrived at the destination, I opened WhatsApp and saw the dreaded popup of death:

Having been a victim of WhatsApp data loss in the past, as soon as I saw this message, I knew something dark was about to take place.

Skip restore is certainly never the solution.

Restore is the way forward, but if your backup file is corrupted or something else goes wrong, say goodbye to your chats.

I tapped on Restore, hoping that all would go well. Indeed, at first, it seemed like all was going well. My chats were being restored using the previous day's backup. But then suddenly, the phone's screen timed out and went off. When I unlocked the phone, the restoring process was stuck at 36% and wouldn't move an inch.

I waited a while, but since it wouldn't move, I closed the app and reopened it. It did not take me to the ongoing restoring process but took me straight to the chats section. It was at this point that I realized it wasn't all the chats that had been restored and I figured that I would need to restart the restoring process for the missing chats to be restored.

To do this, I chose to uninstall WhatsApp. But my phone asked if I wanted to keep app data. I choose yes.

After I reinstalled WhatsApp, it didn't ask to initialize the user profile from scratch as I expected. And I realized this was because I didn't choose to clear the app data.

So I uninstalled WhatsApp again, but this time accepted that the app data be deleted.

Big mistake!

Sure enough, the app opened up after reinstallation, and then I went through the process. It sent an OTP to my email and then started looking for Google Drive backups. It was at this point that I realized WhatsApp had not stored a single Google Drive backup since April 21st.

And then I decided that this would be too far back and that I would use my local backups instead. So I deleted WhatsApp again, reinstalled and turned on airplane mode hoping that it would ask to check the local databases this time.

I waited for a long while and it was still not finding any local backups. It was at this time I realized I had lost the backup while reinstalling! In fact, not only did I lose the backups, but I lost all my media as well. I lost the entire com.whatsapp folder. Come on!

Okay, so to be honest, I only later realized that the option for Google Drive backup in my settings was set to "Only when I tap Back up". I had no idea when that option was selected in the first place.

Although some may choose to blame me because of what I just said, I would like to state that a customer or user should never ever have to worry about data storage.

Ever.

Remember that most users are not even technically minded. I have met older people who even had no idea that they could turn off automatic media downloads. How then would such people be expected to take full responsibility for data retention?

My recommendation

Even if the WhatsApp team cannot at this point migrate all messages to the cloud, they should provide some sort of functionality that allows the second party of an E2E encrypted chat to "share" the entire chat history with the victim of data loss, so that it synchronizes the chat history of the affected person independently of a local/cloud backup.

Also, if a user turns off their Google Drive backups, they should be alerted periodically.

So I was recently trying to debug an application. It was an extremely buggy legacy software that kept giving everyone headaches - from the users to the founders. Several developers had been on the project but each left behind huge amounts of unfinished work - as well as more and more bugs. Some of these bugs were so bad that the reports being generated were full of incorrect data.

One of the features of the application was to generate terminal reports of all the students and assign positions/rankings to each subject they were tested on, in order to determine which child was first place, second place, and so on.

For confidentiality, I will not post the original code.

However, while trying to rewrite the ranking mechanism, I ran into an interesting problem and thought, "Hey, let me leave this to ChatGPT to do".

ChatGPT has proved very helpful to me in my coding journey. I began with CoPilot last year but signed up for ChatGPT this year when it launched. If you've followed my blog for a while, you know that I like to explore AI and also explore deep questions about the technology. In fact, last year, I mused about the possibility of AI becoming "infinite" in its capabilities.

CoPilot was great, but it kept generating outdated and incorrect code for me. So I did not continue using it. ChatGPT was even better - with the ability to actually explain things in simple language. However, I never really used ChatGPT for coding until very recently. At first, I gave it simpler queries and it seemed to do very well. But today, I gave it a tougher challenge and it ended up wasting hours of my time. I also noticed that it kept lagging and freezing and I had to refresh the page each time that happened.

The problem

Let's jump right into the code.

The problem is this block of code:

<?php
    $students = [
    [
        "STUDENT_ID" => "STD003420",
        "TOTAL_SCORE" => "62.5" 
    ], 
    [
        "STUDENT_ID" => "STD003421",
        "TOTAL_SCORE" => "60.0" 
    ], 
    [
        "STUDENT_ID" => "STD003066",
        "TOTAL_SCORE" => "65.0" 
    ], 
    [
        "STUDENT_ID" => "STD003064",
        "TOTAL_SCORE" => "70.5" 
    ], 
    [
        "STUDENT_ID" => "STD003041",
        "TOTAL_SCORE" => "69.0" 
    ], 
    [
        "STUDENT_ID" => "STD003062",
        "TOTAL_SCORE" => "74.0" 
    ], 
    [
        "STUDENT_ID" => "STD003425",
        "TOTAL_SCORE" => "66.5" 
    ], 
    [
        "STUDENT_ID" => "STD003055",
        "TOTAL_SCORE" => "72.5" 
    ], 
    [
        "STUDENT_ID" => "STD003069",
        "TOTAL_SCORE" => "74.5" 
    ], 
    [
        "STUDENT_ID" => "STD003068",
        "TOTAL_SCORE" => "63.0" 
    ], 
    [
        "STUDENT_ID" => "STD003045",
        "TOTAL_SCORE" => "63.0" 
    ], 
    [
        "STUDENT_ID" => "STD003115",
        "TOTAL_SCORE" => "57.0" 
    ], 
    [
        "STUDENT_ID" => "STD003427",
        "TOTAL_SCORE" => "69.5" 
    ], 
    [
        "STUDENT_ID" => "STD003002",
        "TOTAL_SCORE" => "72.5" 
    ], 
    [
        "STUDENT_ID" => "STD003536",
        "TOTAL_SCORE" => "60.5" 
    ], 
    [
        "STUDENT_ID" => "STD003122",
        "TOTAL_SCORE" => "87.0" 
    ], 
    [
        "STUDENT_ID" => "STD003534",
        "TOTAL_SCORE" => "79.0" 
    ], 
    [
        "STUDENT_ID" => "STD003049",
        "TOTAL_SCORE" => "77.0" 
    ], 
    [
        "STUDENT_ID" => "STD003121",
        "TOTAL_SCORE" => "66.0" 
    ], 
    [
        "STUDENT_ID" => "STD003047",
        "TOTAL_SCORE" => "85.0" 
    ], 
    [
        "STUDENT_ID" => "STD003043",
        "TOTAL_SCORE" => "86.5" 
    ], 
    [
        "STUDENT_ID" => "STD003185",
        "TOTAL_SCORE" => "70.5" 
    ], 
    [
        "STUDENT_ID" => "STD003001",
        "TOTAL_SCORE" => "82.5" 
    ], 
    [
        "STUDENT_ID" => "STD003003",
        "TOTAL_SCORE" => "86.5" 
    ], 
    [
        "STUDENT_ID" => "STD003538",
        "TOTAL_SCORE" => "70.0" 
    ], 
    [
        "STUDENT_ID" => "STD003537",
        "TOTAL_SCORE" => "70.0" 
    ], 
    [
        "STUDENT_ID" => "STD003535",
        "TOTAL_SCORE" => "80.0" 
    ], 
    [
        "STUDENT_ID" => "STD003053",
        "TOTAL_SCORE" => "73.5" 
    ], 
    [
        "STUDENT_ID" => "STD003120",
        "TOTAL_SCORE" => "77.0" 
    ], 
    [
        "STUDENT_ID" => "STD003059",
        "TOTAL_SCORE" => "70.0" 
    ], 
    [
        "STUDENT_ID" => "STD003426",
        "TOTAL_SCORE" => "61.0" 
    ], 
    [
        "STUDENT_ID" => "STD003424",
        "TOTAL_SCORE" => "60.0" 
    ], 
    [
        "STUDENT_ID" => "STD003422",
        "TOTAL_SCORE" => "50.0" 
    ], 
    [
        "STUDENT_ID" => "STD003118",
        "TOTAL_SCORE" => "68.0" 
    ]
  ];

  usort($students, function($a, $b) {
      return $b['TOTAL SCORE'] - $a['TOTAL SCORE'];
  });

  var_dump($students);
?>

I wished to sort this class of 34 students based on their total scores, in descending order. The easiest way, of course, was to pass a callback to PHP's usort() method and sit back.

When I ran it, however, it seemed to have trouble getting the first value correct. I already know how usort() works under the hood, so that's not the issue. And you can see that my callback is correct. But instead of returning 87.0 as the correct answer, it returned 86.5.

This was puzzling, because 86.5 can never be greater than 87.0.

So I decided to ask our new best friend - ChatGPT.

Skipping to the response...

Alright, so I decided to copy the new code and use it.

As I expected, it did not work. So I went back to ChatGPT to complain about it, and even pasted the new code in there.

And just like that, it left me hanging:

But I still needed an answer and so I regenerated the response:

But interestingly, the answer it got was also not correct. Here's a snippet of it:

Looool... how on earth is 85.0 greater than 86.5?

Someone may say, "but why are you comparing strings?" Well, it turns out that if you compare these same strings "85.0" and "86.5" in PHP, you get the right answer.

So it's not about the usage of strings at all.

I then complained once more and this time, ChatGPT was just so overwhelmed that it gave up midway. (And even got the programming language wrong.)

To anyone who may be confused, the reason why the sorting didn't work is that the usort() method, after performing the subtraction, converts the result to an integer. And if the difference is something as small as -0.5, it assumes the result is 0, and so it sees both 87 and 86.5 as being equivalent. The solution, of course, is to use a different sorting method. I expected ChatGPT to notice this and warn me, but it failed to do so.

Conclusion

Is AI going to replace programmers? Not anytime soon.🥱

When building an application in Laravel, it is often the case that files would have to be uploaded.

Running an endpoint in Postman or designing a view in order to test that the file is being processed properly can be a cumbersome task. This guide will teach you how to upload real files in Laravel tests, instead of using fakes, so that we can actually read the content of the file and be sure that it's processing properly.

Using a fake file in your test is convenient when you only need to assert that a file has been uploaded and/or saved. However, it is impractical when the content of the given file matters to you.

In this guide, we will upload an Excel spreadsheet so that we can use and test the rows and columns contained therein.

Prerequisites

These are important prerequisite knowledge needed for this tutorial:

• Familiarity with Laravel 5.5+

• Laravel testing with PHPUnit. The latest versions of PHPUnit, such as version 9 or 10, should be sufficient.

Overview

In this article, we'll work on a feature that extracts data from a row in a spreadsheet and persists it in the database.

For the sake of this tutorial, we'll deal with spreadsheets in a common format such as XLSX or CSV. Also, we are going to use the Spartner Laravel Excel package (formerly Maatwebsite/Excel).

Then we'll write the tests and controllers needed. The application we'll be working on is one that takes financial data from a spreadsheet and processes it to create metrics.

Installation

To install the package, run composer require maatwebsite/excel in a terminal.

No further configuration is needed, but you can still explore the options available. Just run php artisan vendor:publish --provider="Maatwebsite\Excel\ExcelServiceProvider" --tag=config to publish the configuration file, which contains a long list of options.

Creating spreadsheet

Next, we need to create a spreadsheet. You may use any software of your choice but I have already created a spreadsheet in Google Sheets with just a heading row and one single row of data.

Your spreadsheet could look like this:

Testing

Where should we save the spreadsheet?

Let's begin by creating a folder in our Tests directory. It may be a good idea to save the spreadsheet in a folder called "Assets" within your "tests" directory.

My directory looks like this:

Basic structure of test class

Next, let's create the test class. You can create it in the tests/Feature namespace.

When it comes to creating test classes, I often like to do it without explicitly naming the classes. I've explained my reasons in a previous article. If you want to use that approach, though, just be aware that it'll affect the way you use the php artisan test --filter command. For example, you will no longer be able to selectively run only tests in that class by passing the name of the class to the filter argument. However, you will still be able to call individual classes one by one.

That being said, let's create an anonymous class like this:

<?php

namespace Tests\Feature;

use Tests\TestCase;
use Illuminate\Foundation\Testing\LazilyRefreshDatabase;

return new class extends TestCase
{
    use LazilyRefreshDatabase;

    public function test_that_excel_details_are_saved()
    {
        //
    }
};

We'll return to this class in a moment, but we need to examine the work so far.

First, we have set up the file as an anonymous PHP class by just returning a new class.

Our new class then extends the default TestCase class, which is responsible for bootstrapping the application, and setting up and tearing down tests.

Next, we have imported the LazilyRefreshDatabase trait. This trait cleans out your database in between tests only if the next test to be run actually makes use of the database. This is an improvement over the RefreshDatabase trait in older versions of Laravel. However, you are free to use the latter if you wish.

After using the trait, we have defined the test function and called it test_that_excel_is_processed. Prepending test to the function's name will cause PHPUnit to recognize it as a valid test and run it.

If we need to run this test, all we need to do is to pass its name to the filter flag:

php artisan test --filter test_that_excel_is_processed

Let us move on to add a bit more flesh to the class. You can skip this and move to the next example, but we need to do it this way in order to make things easier to understand:

<?php

namespace Tests\Feature;

use App\Imports\FinancialNoteImport;
use Illuminate\Http\UploadedFile;
use Tests\TestCase;
use Illuminate\Foundation\Testing\LazilyRefreshDatabase;

return new class extends TestCase
{
    use LazilyRefreshDatabase;

    public function test_that_excel_details_are_saved()
    {
        // We will remove this. Don't worry about it.
        $this->markTestIncomplete();
    }
};

At this stage, we still haven't written any actual testing code. However, we just added two new imports:

• The FinancialNoteImport will point to an Import class that will handle the processing of the document. Read about Imports here.

• The framework's UploadedFile import helps us to fake files while testing. We will populate this with the content of our actual file.

We have also marked the test as incomplete so that it will not be run when we run all other tests.

Using UploadedFile

Let's talk a bit more about why we need to use the Illuminate\Http\UploadedFile class and its limitations.

Basically, the whole point of this test - or what we aim to achieve - is to upload a file as though we were a user and then test that the exact content of the file is what is being saved in the database.

Sounds easy, but the question is how do we do this?

If we navigate to the Laravel documentation section on Testing File Uploads, we see a lot of examples about faking an UploadedFile instance. In those examples, we also see that we are encouraged to fake the Storage Facade as well with Storage::fake(). What this means is that we can pretend to create a file of any extension and then proceed to perform a bunch of assertions - like testing that the file has been uploaded and exists in storage, etc., etc., etc.

But the documentation really doesn't help if we need to make use of the contents of the file. What we want is a way to use an existing file. If you try to just get a real file from your storage disk and use it anyway, the test class will never be able to access the file.

I once did this in a project and had to scrap it, because I couldn't figure out why it never worked. The Assets directory contained three files. I split up a file in 3 parts and named them chunk1, chunk2, and chunk3. Here, I was trying to iterate through the Assets directory and upload each chunk to an endpoint that was responsible for taking these chunks one by one and merging them afterward:

$chunks = ['chunk1', 'chunk2', 'chunk3'];

// Loop sending of three chunks in the Assets/ directory
for ($i = 0; $i < 3; $i++) {
    $chunk = file_get_contents(base_path('tests/Assets').'/'.$chunks[$i]);

    $this->actingAs($this->user)
        ->patchJson(route('api.media.upload-chunk'));
}

That was a long time ago and I never needed to do it again... until recently.

This time, however, I decided to take the bull by the horns and dig deep into the Laravel source code for answers.

Fortunately, I found something. This is from the Illuminate\Http\Testing\FileFactory class:

Observe that the createWithContent() method appears nowhere in the official documentation:

Finding it in the source code was a big relief. This made everything easy for me.

As a rule of thumb, I recommend digging through source code as a last resort if you need to do something that hasn't been documented yet. Sometimes, creators of frameworks write a lot of methods without documenting them. So dig first, and if you don't find anything, come up with your own solution.

Who knows? You might even be able to contribute your solution to the original repo!

Anyway, finding this method was significant as it meant I only needed to use it in my test and I'd be good to go. Therefore. I only had to modify my test class.

Since Laravel tests only recognize fake uploaded files, this is the way to go if you really need to use your own data within the files:

public function test_that_excel_is_processed()
{
    $fileContent = file_get_contents(base_path('tests/Assets/My Spreadsheet.xlsx'));

    // We can either use the same name or another. Doesn't matter.
    // I chose to use "sample"
    $file = UploadedFile::fake()->createWithContent('sample.xlsx', $fileContent);

    // This will process and save the contents of the file.
    // we don't need to go into detail here.
    (new FinancialNoteImport)->import($file);

    $this->assertDatabaseCount('financials', 1);
    $this->assertDatabaseHas('financials', [
        'total_issued_shares' => 1000000,
        'dividends_paid' => 0,
        'weighted_average_cost_of_capital' => 0.18,
        'capital_expenditure' => 2,
        'depreciation' => 4,
        'accumulated_depreciation' => 6,
        'historical_cost_of_assets' => 9,
        'cash_flow_from_operations' => 590,
    ]);
}

In this example, we simply retrieve the content of our spreadsheet into memory. (Make sure the file is not too large)

Next, we create a faked UploadedFile instance which we pre-populate with the content of the spreadsheet.

Then we go ahead to run the import using our custom Import class.

Lastly, we run two assertions: the first to ensure that the database contains only one record; the latter to check the values. We use the same values here that we configured in the spreadsheet.

Now we can run the aforementioned command: php artisan test --filter test_that_excel_is_processed.

Conclusion

Our test passes with flying colours!🎉🎉🎉

If we'd like to be extra sure that this is working, we can add $this->assertDatabaseCount('financials', 0); at the beginning of the test function to ensure that the database table is truly empty before running the test.

In this article, we have explored how to upload real files into Laravel tests. We only needed to find the right method for the operation, manually store a predefined file, load the file during the test, and check the database to make sure the file's contents were truly captured.

Also note that aside from manually digging through the source code to find the right method, Laravel has its entire API documentation available online. It requires a bit of digging as well but may be preferable to using the source code.

If there are any questions, don't hesitate to type them out in the comment section.

Usually, you'd create an SSH key pair, save the private key on your machine and store the public key in the authorized_keys file of your Linux server. Having these keys make it easy for you to be authenticated without a password when you try to access your server remotely.

For those who use Linux and Mac, you usually have the SSH utility already installed. But when you're in the Windows ecosystem, a lot of things aren't handed to you on a silver platter.

Most tutorials would teach you to install an app called Putty and use it when you need to connect to your server but behold... I teach you a new way today.

Tools needed

1. First, you need a Windows machine. Connected to the internet.

2. Next, you need the ssh utility. So go ahead and open command prompt and type ssh

   If you have it already, you should get something like this:

   

   If you do not see that, try to install or enable SSH.

Create a custom command

Now make sure you have your private key to the server. If you already had Putty, then it means you already had a private key stored somewhere on your computer. You just need to locate it. Make sure to use the original private key, not Putty's .ppk format.

Now, before I proceed, I wish to give credit to this StackOverflow answer for guiding me in the right direction.

Let's proceed. Please note that you can do the following through Windows Explorer if you wish.

1. Open cmd.exe (Command Prompt)

2. Navigate to your user directory. For example, cd C:\Users\john. In my case, the username is "user", but I will stick with "john" for this post in order not to confuse anyone.

3. Run: mkdir commands

4. Run: cd commands

5. Run the following one after the other to create and populate a file where we'd house our commands. You can name it anything you want, but the extension must be cmd:

   1. echo @echo off >> init.cmd

   2. echo doskey open-my-server=ssh -i "C:\Users\john\.ssh\id_secret_key" root@xxx.xxx.xxx.xxx >> init.cmd

      make sure to replace xxx.xxx.xxx.xxx with your server's IP address. Also, the -i flag points to our identity file (private key).

6. Verify the content of the new file with TYPE init.cmd :

   

7. Make your script automatically available to Command Prompt by adding the path to your file in the registry: reg add "HKCU\Software\Microsoft\Command Processor" /v AutoRun /t REG_EXPAND_SZ /d "%"USERPROFILE"%\commands\init.cmd" /f

8. Restart command prompt

9. Now you can run open-my-server and it should just connect in the terminal beautifully.

Conclusion

So that's it! I hope you enjoyed this. Your comments, questions and feedback are most welcome!

Merry Christmas!

Before you read, I want to state emphatically that I am not an AI researcher. I'm not a professor of any sorts...

A few moments ago, I saw a notification on Notion - new AI capabilities in the famous note-taking application:

According to this headline, you can now suggest to Notion what you'd like to see, and it will be generated for you. Computers have now inched closer to the "let there be this or that" point. Basically, you can now tell a computer what you want to see, and it will be done for you.

This isn't exactly new, of course. Many of you have already experimented with ChatGPT at this point. It can solve homework, act as a terminal, tell jokes, write cover letters, and even defend wrong answers with solid arguments.

So you already know that we are at such a point in time as has never been in the history of mankind.

However, with computers gaining such strong abilities even with our currently limited classical computing power, one can only ponder on that headline, and begin to think about it seriously. Is AI infinite?

Well, for starters, let's look at our own biological makeup as humans. We aren't infinite. Not even close.

What does it mean to be finite? Oxford dictionary tells us it is to be "limited in size or extent". This is not only talking about physical limitations in our growth or size but also about our mental capabilities. We forget. We make silly mistakes. We fall sick. We die.

But are we really finite? This would need to be considered across two main areas: physiologically and psychologically.

Physiologically, we are plagued with a billion diseases. We cannot lift a car with a single finger. We are severely limited. We cannot breathe underwater. We cannot fly. We cannot go to space without special suits. We cannot survive extreme temperatures. The list is endless, really.

Psychologically, we cannot handle heavy mental processing. We cannot think about two things at once. The multitaskers among you are definitely rolling their eyes right now, but it's true. At each given split-second, you are focused on only one thing at a time. You may be able to switch between topics so fast that you experience the illusion of multitasking, but in reality, I do not believe it is possible. As you age, it gets even worse. You forget several things. You take more and more time to figure out solutions to problems. You begin to wonder where the brain that could once understand complex algebra has hidden itself. Need I say more? The truth is right before us.

Now that we have established the fact that we aren't infinite, let us ask: can finite beings create infinite beings?

The short answer is no. A big and resounding NO.

Can any machine be infinite?

The reason we have AI in the first place is that we realized there were many things we couldn't trust our minds to do. I must emphasize that we are talking about our minds here. We needed something that could think faster, learn faster, and know so much more than we could ever keep in our individual brains. This is the same reason we began to build mechanical machines. It's the same pattern. Are machines infinite? Not a chance.

Machines are more efficient. That's true. But they are not infinite. They themselves require maintenance, frequent oiling here and there, occasional replacement of parts and the like. Therefore, man is still greater than machine.

But what about AI? It doesn't necessarily need maintenance. It could be trained to train itself. It can even be trained to train and create other AI. That's something mechanical machines cannot do. AI is an attempt to create a machine that can reason like a human being. But is it infinite?

Let's look at a single case. We have seen reports of ChatGPT giving incorrect answers. It's so bad in fact, that StackOverflow quickly jumped up to ban answers given by it. Let me quote a section of the official notice given by StackOverflow:

Overall, because the average rate of getting correct answers from ChatGPT is too low, the posting of answers created by ChatGPT is substantially harmful to the site and to users who are asking or looking for correct answers.

The primary problem is that while the answers which ChatGPT produces have a high rate of being incorrect, they typically look like they might be good and the answers are very easy to produce.

And this is not only a ChatGPT problem. If any of you tried out Github's Copilot, as I did, then you know that out of the 10 auto-generated code blocks, most were incorrect. This was due to various reasons, but I personally observed that sometimes, the answers were given based on an older version of the language or framework, with slightly different syntax. It's basically GIGO. Garbage in, garbage out. If we fed it with pure garbage code, it would generate pure garbage code, because it had no way of autonomously checking the code for correctness.

This is the fundamental issue! AI cannot be said to be infinite if it gives 99% correct answers and still has 1% false answers. In order to be infinite, it must prove itself to be the ultimate source of truth. You should be able to ask it a deliberately extreme question like "what did the president tell his wife last afternoon", and it would search the database and tell you exactly what it was. It should be able to predict, with super accuracy, the outcome of a soccer match.

For it to be infinite, it MUST KNOW EVERYTHING.

If it does not know EVERYTHING, then it is obviously limited in knowledge. This is common logic. This is common sense.

For deep thinkers only:

To be infinite is to be "limitless or endless in space, extent, or size". That includes mental capability. It must not be in doubt about any subject matter. It must not be ignorant about any detail. If you begin to think of the universe as a set of mathematical and physical laws, then it stands to reason that if we destroy this universe and recreate it with the exact same laws, we would arrive at the same conclusion every single time, because 1 + 1 can never be anything other than 2. Therefore, your AI, if it is truly infinite, should be able to understand the laws of the universe with such precision that it knows everything. I may have lost 80% of you here, but all I'm saying is that your AI needs to have a mental capacity that is out of this world, and that is able to encompass all the knowledge ever known to this universe.

Remember that we are dealing with the mental faculty here. We cannot judge it on the basis of strength, health, wealth, and so on. We can only judge based on mental indicators: speed of thought, accuracy of information, reliability, conscience, ability to predict future occurrences, and so on. AI was created to assist the human mind. However, to call it infinite in your marketing is too strong of a claim. The technology still has a long way to go.

Will it ever be infinite?

As far as I am concerned, AI will never be infinite. Why is this so? Very simply put, AI relies on existing human knowledge in order to be useful. Even if you train it with 100% correct data, you will still require it to learn from its interaction with users. And from there, you and I can clearly see how flaws will be introduced. If the beings providing the input are not 100% correct all the time, there is no way on this planet that the machine learning from these beings will be 100% correct.

The conclusion

Now that you've read this, you can rest easy, knowing that while it may take some of your jobs, just as mechanical and electronic machines took away many manual jobs, it will never end up becoming your ruler.

Thank you for reading, and I'd love to hear your comments.

If you're already using Laravel, I just want to share a very quick tip you can use to structure your test classes.

If you're a little clumsy with your nomenclature, when writing tests, you will often run into a stern warning from Composer:

Ouch.

We are facing this issue because the name of our class does not match the name of our PHP file. Our class is named "AnExampleTest" but the file itself is named "ExampleTest". We could also face this issue if the namespace does not match the folder structure.

Sure enough, fixing the file name and the namespace can solve the issue. However, I have found that a better way to declare such tests is to do so as anonymous classes. I was inspired to use this technique by observing the default migration files in Laravel 9.

So do something like this instead:

return new class extends TestCase
{
    /**
     * A basic test example.
     *
     * @return void
     */
    public function test_the_application_returns_a_successful_response()
    {
        $response = $this->get('/');

        $response->assertStatus(200);
    }
};

Since we do not need to import this class anywhere else, this should be a great fit for us.

That's all for now. Thank you for reading!

Except....you're still almost as bad as you were several years ago.

You've tried everything, but you can't seem to understand why your abilities never seem to match up to the market standard. It begins to affect your mind. You feel inferior. You want to give up entirely and become maybe a taxi driver or something.

But hang on! This really isn't about you. It's got nothing to do with you as a person.

I too was stuck in this viscious cycle for really long. That's why I think I'm qualified to talk about this.

Most likely, the problem you have is the same one I had.

In my opinion, the BIGGEST growth killer in this profession is the desire for perfection. You compare yourself to others way too much. You write code, but quickly abandon it when you see someone else do the very same thing in a seemingly better way (or with fewer lines of code).

But you need to realize that code doesn't need to be perfect. At least, not on your first attempt. We all write code and vehemently deny writing such terrible code after a couple of years. My point is - you need to allow yourself to progress.

Beautiful, optimized and efficient code is a journey, not a destination. You need to allow yourself to fail in order to enjoy this journey.

This has been a very short article, but all I want you to remember is this: there isn't just one way of doing something. There isn't "that one perfect approach" to solving a problem with code. Often, there are many different ways. And the more time you spend fantasizing over whether your code is perfect or not, the huger the chunk of time you will waste!

As a beginner, or intermediate programmer, DO NOT worry about perfection. When you can stand on your own two feet confidently, then you can begin to worry about those fine details.

I wish I had heard these words from the beginning of my journey. They would have saved me the trauma of thinking I simply wasn't good enough.

Now, I commit such knowledge into your bosom. Happy coding!