DEV Community: Eddie Goldman

How to Replace “php artisan” With a Short Command in Windows PowerShell

Eddie Goldman — Thu, 13 Nov 2025 15:25:27 +0000

Why I Wanted a Shorter Laravel Command

If you use Laravel every day, you type the same command again and again:

php artisan ...

For example:

php artisan optimize
php artisan migrate
php artisan make:model User

After typing this dozens of times per day, it becomes slow and annoying.
So I decided to make my workflow faster. My goal was simple:

Use just one letter — “a” — instead of “php artisan”.

Why a Normal Alias Does Not Work in Windows PowerShell

Windows PowerShell does not support this kind of alias correctly.
If you try to create a simple alias, you will see errors like:

Could not open input file: optimize

This happens because PowerShell incorrectly runs:

php optimize

instead of:

php artisan optimize

To fix this, we need a function that sends all arguments directly to php artisan.

Step-by-Step: Create the “a” Command in PowerShell

Follow these steps to make your custom a command work everywhere.

1. Open PowerShell

Press Start → PowerShell.

2. Check Your Profile File Path

Run:

echo $PROFILE

You will see something like:

C:\Users\YourName\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1

3. Open the Profile File

Run:

notepad $PROFILE

If the file does not exist, choose Yes to create it.

4. Add This Function Inside the File

This is the correct function that makes a work exactly like php artisan:

function a {
    & php .\artisan @args
}

This line:

runs php artisan
passes all arguments to it (@args)
works in any Laravel project folder
supports all Artisan commands normally

Save the file and close Notepad.

5. Reload the Profile

Run:

. $PROFILE

(important: dot, space, then $PROFILE)

Your new command is now active.

How to Use the New “a” Command

Now you can replace anything like this:

php artisan optimize

with:

a optimize

More examples:

a migrate
a tinker
a config:cache
a make:model Product
a make:controller Admin/DashboardController

It behaves 100% the same as:

php artisan ...

but much faster to type.

Why This Saves Time

If you run multiple Artisan commands during development, this simple shortcut:

saves keystrokes
speeds up your workflow
makes repetitive tasks easier
keeps your hands on the keyboard
reduces typing effort

It takes less than one minute to set up but improves your daily coding speed immediately.

See my blog post: https://eddie-goldman.com/how-to-replace-php-artisan-with-a-short-command-in-windows-powershell/

What Is the Walrus Operator (:=) in Python and Why It's So Useful

Eddie Goldman — Tue, 17 Jun 2025 23:06:38 +0000

Back in Python 3.8, a new syntax quietly showed up and turned out to be surprisingly handy. It’s called the walrus operator (:=).
No, it’s not an actual walrus — but it does help you write cleaner code with fewer lines.

What does it actually do?

In short: it lets you assign a value as part of an expression.
Think of it as saying:

“I want to save this value and use it right now — in one go.”

Here’s an example:

while (line := input(">>> ")) != "exit":
    print(f"You typed: {line}")

What’s happening here:

You ask the user for input (input(...))
You store that in the variable line
Then immediately check if it’s "exit"

All in one concise line.
No need to write line = input(...) and then if line != "exit" separately.

When should you use it?

Use it when:

You want to assign and compare in the same line (e.g., in a while or if)
You’re inside a loop or list comprehension
You want to avoid repeating the same function call

A word of caution: avoid overusing it. If it makes your code harder to read, it might not be worth the compactness.

Bonus example: reading a file line-by-line

with open("example.txt") as file:
    while (line := file.readline()):
        print(line.strip())

This is a clean one-liner for looping through file lines without a separate assignment above the loop.

Final thoughts

The walrus operator might look unusual at first, but once you start using it in the right situations, it becomes a natural part of your coding toolkit.
Try it in small places, and you may find it simplifies your logic and keeps your code more expressive.

PHP Arrow Functions – Simple, Short, and Effective

Eddie Goldman — Wed, 11 Jun 2025 00:17:19 +0000

What is an Arrow Function in PHP?
An arrow function (also called a “short closure”) is a new way to write anonymous functions in PHP. It’s much shorter and easier to read than the classic function syntax.

When do we use Arrow Functions?
Use an arrow function when you want a quick and simple anonymous function, for example, when working with arrays or collections (array_map, array_filter, Laravel Collections, and so on).

How do you write an Arrow Function?

$sum = fn($a, $b) => $a + $b;
echo $sum(2, 3); // Outputs 5

The same with classic function syntax:

$sum = function($a, $b) {
    return $a + $b;
};
echo $sum(2, 3); // Outputs 5

Main differences of Arrow Functions:

Short syntax: fn($arg) => ...
Always returns: The value on the right side is always returned.
No need for use: Arrow functions can see variables from outside by default.

Example using an outside variable:

$multiplier = 2;
$numbers = [1, 2, 3];
$result = array_map(fn($n) => $n * $multiplier, $numbers);
// [2, 4, 6]

When is it best to use Arrow Functions?

Quick array operations
In collection methods (Laravel)
When you need very simple logic

When NOT to use Arrow Functions?

If the function needs more than one statement (arrow functions only allow one expression)
For complex logic, use the classic function

Other examples

Filter an array with an arrow function:

$users = [
    ['name' => 'Eka', 'age' => 25],
    ['name' => 'Gio', 'age' => 17],
];
$adults = array_filter($users, fn($user) => $user['age'] >= 18);
// Only Eka will stay in the array

Same with classic function:

$adults = array_filter($users, function($user) {
    return $user['age'] >= 18;
});

Simple PHP example:

$nums = [1, 2, 3, 4, 5];
$squared = array_map(fn($n) => $n * $n, $nums);
// [1, 4, 9, 16, 25]

Can we use an Arrow Function directly when setting a variable’s value?
Yes! You can use an arrow function right when you set a variable’s value. For example:

$numbers = [2, 4, 8, 16];
$all_even = collect($numbers)->every(fn($n) => $n % 2 === 0);
// $all_even will be true if all numbers are even

Or with a simple array:

$users = [
    ['name' => 'Nika', 'age' => 21],
    ['name' => 'Lika', 'age' => 22],
];
$all_adult = array_reduce($users, fn($carry, $user) => $carry && $user['age'] >= 18, true);
// $all_adult will be true if all users are adults

Summary:
Arrow functions in PHP let you write very short and simple anonymous functions. They make your code cleaner when you need only one expression. You can use them for working with arrays, collections, and even when setting a variable’s value with a function result.

Efficient Data Processing with PHP Generators

Eddie Goldman — Sun, 01 Jun 2025 20:20:00 +0000

Modern PHP includes Generators, which let you work with large datasets without using too much memory. Instead of building a huge array and then looping through it, a Generator uses yield to return one item at a time. This keeps only the current value in memory.

Example: Generating Numbers

function getNumbersWithGenerator(int $max): Generator {
    for ($i = 1; $i <= $max; $i++) {
        yield $i;
    }
}

// Only one number is in memory at once:
foreach (getNumbersWithGenerator(1_000_000) as $n) {
    // Process $n…
}

If you tried to build an array of one million numbers first, PHP would use a lot of memory. With a Generator, it stays small.

Example: Reading a Large CSV File

function readCsvLineByLine(string $filename): Generator {
    if (!is_readable($filename)) {
        throw new InvalidArgumentException("Cannot read: $filename");
    }
    $handle = fopen($filename, 'r');
    if (!$handle) {
        throw new RuntimeException("Failed to open: $filename");
    }

    // First row is the header:
    $header = fgetcsv($handle);
    while (($row = fgetcsv($handle)) !== false) {
        yield array_combine($header, $row);
    }
    fclose($handle);
}

// Use it like this:
foreach (readCsvLineByLine(__DIR__ . '/large-data.csv') as $record) {
    // Each $record is an associative array, e.g. ['id'=>'123', 'name'=>'Alice', …]
    // Process $record without loading the entire file into memory.
}

Because fgetcsv() reads one line at a time and yield returns one row, PHP never loads the whole file at once.

When to Use Generators

Fetching thousands of database rows: yield each row instead of fetchAll().
Processing large log files or text files line by line.
Any situation where you would otherwise build a huge array.

Generators make your PHP code run “lazy”: values are produced on demand. This keeps memory usage low and avoids slowdowns. Next time you need to handle big data in PHP, try a Generator function!

Early Return vs. Classic If-Else: A Universal Pattern for Writing Cleaner Code

Eddie Goldman — Mon, 26 May 2025 18:10:04 +0000

Writing conditional logic is something every developer does—no matter the language. But how you structure those conditions affects how readable, testable, and maintainable your code becomes.

In this post, we’ll look at two common approaches:

Early return (also called guard clause)
Classic if...else nesting

These patterns are relevant across any language—from PHP and JavaScript to Python, Go, or Java.

What Is Early Return or Guard Clause?

Early return means exiting a function as soon as a certain condition is met—usually to handle an edge case or invalid input.

A guard clause is a specific use of early return at the top of the function, to prevent deeper logic from running if key conditions aren’t met.

This avoids unnecessary nesting and keeps your core logic flat and easy to follow.

Example 1: Classic `if...else` (Nested Logic)

PHP Version:

function send_welcome_email($user) {
    if ($user) {
        echo "Sending welcome email to {$user['email']}";
    } else {
        return;
    }
}

JavaScript Version:

function sendWelcomeEmail(user) {
    if (user) {
        console.log(`Sending welcome email to ${user.email}`);
    } else {
        return;
    }
}

In both cases, the real logic is wrapped inside an if block, which can become messy as the function grows.

Example 2: Early Return / Guard Clause

PHP Version:

function send_welcome_email($user) {
    if (!$user) {
        return;
    }

    echo "Sending welcome email to {$user['email']}";
}

JavaScript Version:

function sendWelcomeEmail(user) {
    if (!user) {
        return;
    }

    console.log(`Sending welcome email to ${user.email}`);
}

This structure handles the invalid case immediately, then continues with the main logic. It’s easier to read and requires less indentation.

Benefits of Using Guard Clauses

Reduces code nesting and cognitive load
Keeps the core logic visually prioritized
Handles edge cases early and clearly
Makes the function easier to modify and extend

This approach works well in any language, because it's a logic structuring choice—not a language feature.

Real-World Example: Validating a Request

Classic Nested Style (PHP)

function process_payment($request) {
    if (isset($request['amount'])) {
        if ($request['amount'] > 0) {
            // process payment
        } else {
            throw new Exception("Amount must be positive");
        }
    } else {
        throw new Exception("Amount is required");
    }
}

Guard Clause Style (JavaScript)

function processPayment(request) {
    if (!request.amount) {
        throw new Error("Amount is required");
    }

    if (request.amount <= 0) {
        throw new Error("Amount must be positive");
    }

    // process payment
}

In both examples, the invalid paths exit early. The result is cleaner, flatter, and easier to follow.

Conclusion

Early returns and guard clauses are a universal technique for writing better code. Whether you're using PHP, JavaScript, Python, Go, or Java, the idea is the same:

Handle bad input early, exit fast, and let the main logic stay clean and focused.

Avoid deeply nested if...else structures when you can simplify your function with a few early checks. It will lead to code that’s easier to read, maintain, and reason about.

Enable or Disable console.log Globally in JavaScript

Eddie Goldman — Sat, 17 May 2025 20:20:26 +0000

Enable or Disable console.log Globally in JavaScript

Sometimes, during development or debugging, you need to quickly enable or disable logging globally across your entire JavaScript application. Here's a straightforward approach to achieve this.

Step-by-Step Guide

Step 1: Store the Original `console.log`

Before we override the console.log function, it's crucial to keep a reference to the original function.

let original_console_log = console.log;

This ensures you can restore the original functionality anytime you want.

Step 2: Create a Control Function

Next, create a function that can toggle logging on and off by replacing console.log.

let logging_enabled = true;

function set_logging(enabled) {
    logging_enabled = enabled;
    console.log = enabled ? original_console_log : function () {};
}

Here's what's happening:

When enabled is true, console.log points back to its original behavior.
When enabled is false, console.log becomes an empty function, effectively doing nothing.

Step 3: Enable or Disable Logging

Now you can use your set_logging function to control logging:

set_logging(true);  // Enables logging
console.log('Logging is enabled!');  // ✅ Appears in console

set_logging(false); // Disables logging
console.log('Logging is disabled.'); // ❌ Will NOT appear

set_logging(true);  // Enables logging again
console.log('Logging is re-enabled!'); // ✅ Appears in console

Practical Example

Here's a complete usage scenario:

let original_console_log = console.log;
let logging_enabled = true;

function set_logging(enabled) {
    logging_enabled = enabled;
    console.log = enabled ? original_console_log : function () {};
}

set_logging(true);  // Enables logging
console.log('Always works');  // Appears

set_logging(false); // Disables logging
console.log('This will not appear');  // Does NOT appear

set_logging(true);  // Enables logging again
console.log('This will appear');  // Appears

Why use this method?

Global control: Quickly enable or disable logs across your entire application.
Clean console: Useful to prevent unnecessary clutter when debugging specific parts of your code.

Caution

Overriding console.log globally might have side effects if your application or external libraries depend heavily on logging. Use with caution and primarily for development or debugging scenarios.

App::environment() vs app()->environment() – Practically No Difference

Eddie Goldman — Thu, 15 May 2025 21:21:50 +0000

In Laravel, we often have more than one way to do the same thing. In this case, let’s see if there’s any real difference between these two methods for getting the current environment:

App::environment()
app()->environment()

Let’s write a small test to compare how fast each one is:

$start = microtime(true);
$env1 = App::environment();
$time1 = microtime(true) - $start;

$start2 = microtime(true);
$env2 = app()->environment();
$time2 = microtime(true) - $start2;

$result = [
    'App::environment()' => [
        'value' => $env1,
        'time' => number_format($time1, 4) . ' seconds'
    ],
    'app()->environment()' => [
        'value' => $env2,
        'time' => number_format($time2, 4) . ' seconds'
    ]
];

dd($result);

Output

array:2 [
  "App::environment()" => array:2 [
    "value" => "local"
    "time" => "0.0001 seconds"
  ]
  "app()->environment()" => array:2 [
    "value" => "local"
    "time" => "0.0000 seconds"
  ]
]

What Did We Learn?

Both methods return the same value — "local", so there is no functional difference. The time difference is extremely small:

App::environment() — 0.0001 seconds
app()->environment() — 0.0000 seconds

Technically, app() might be slightly faster since it directly returns the application instance.

Which One Should You Use?

Want cleaner, more readable code? Use App::environment()
Need the fastest performance (like inside a big loop)? Use app()->environment()

Recommendations

Pick one style and stick to it in your project for consistency.
The performance difference is too small to worry about — don’t over-optimize.
Use App::environment() for clarity, or app()->environment() for flexibility.
If you often work with helper functions or service container access, app() can feel more natural.

Final Thoughts

They both work exactly the same. Choose the one that fits your style or project needs. Just remember: for most use cases, the difference doesn't really matter.

DEV Community: Eddie Goldman

How to Replace “php artisan” With a Short Command in Windows PowerShell

Why I Wanted a Shorter Laravel Command

Why a Normal Alias Does Not Work in Windows PowerShell

Step-by-Step: Create the “a” Command in PowerShell

1. Open PowerShell

2. Check Your Profile File Path

3. Open the Profile File

4. Add This Function Inside the File

5. Reload the Profile

How to Use the New “a” Command

Why This Saves Time

What Is the Walrus Operator (:=) in Python and Why It's So Useful

What does it actually do?

When should you use it?

Bonus example: reading a file line-by-line

Final thoughts

PHP Arrow Functions – Simple, Short, and Effective

Efficient Data Processing with PHP Generators

Early Return vs. Classic If-Else: A Universal Pattern for Writing Cleaner Code

Example 1: Classic if...else (Nested Logic)

PHP Version:

JavaScript Version:

Example 2: Early Return / Guard Clause

PHP Version:

JavaScript Version:

Benefits of Using Guard Clauses

Real-World Example: Validating a Request

Classic Nested Style (PHP)

Guard Clause Style (JavaScript)

Conclusion

Enable or Disable console.log Globally in JavaScript

Enable or Disable console.log Globally in JavaScript

Step-by-Step Guide

Step 1: Store the Original console.log

Step 2: Create a Control Function

Step 3: Enable or Disable Logging

Practical Example

Why use this method?

Caution

App::environment() vs app()->environment() – Practically No Difference

Output

What Did We Learn?

Which One Should You Use?

Recommendations

Final Thoughts

Example 1: Classic `if...else` (Nested Logic)

Step 1: Store the Original `console.log`