DEV Community: Stevie G

What’s New in PHP 8.5

Stevie G — Thu, 14 May 2026 00:25:15 +0000

PHP 8.5 is here, and while it may not feel quite as dramatic as PHP 8.4’s property hooks and asymmetric visibility, it brings some excellent quality-of-life improvements for everyday PHP developers.

This release focuses on cleaner code, safer APIs, better debugging, improved URL handling, and small but useful syntax improvements.

In this article, we’ll look at the most important PHP 8.5 features with simple examples.

1. The New Pipe Operator

One of the biggest additions in PHP 8.5 is the new pipe operator: |>.

The pipe operator lets you pass the result of one expression into the next function, making transformation code easier to read from left to right.

Before PHP 8.5

$title = ' PHP 8.5 Released ';

$slug = strtolower(
    str_replace('.', '',
        str_replace(' ', '-',
            trim($title)
        )
    )
);

echo $slug;

PHP 8.5

$title = ' PHP 8.5 Released ';

$slug = $title
    |> trim(...)
    |> (fn($value) => str_replace(' ', '-', $value))
    |> (fn($value) => str_replace('.', '', $value))
    |> strtolower(...);

echo $slug;

Why it’s useful

This makes code easier to follow because each step happens in order.

Instead of reading deeply nested function calls from the inside out, you can read the logic from top to bottom.

This is especially useful when cleaning strings, processing arrays, transforming request data, formatting output, or building readable data pipelines.

2. New URI Extension

PHP 8.5 adds a new built-in URI extension for working with URLs and URIs in a more structured way.

For years, PHP developers have often used parse_url(), manual string handling, or third-party packages for more advanced URL work. PHP 8.5 gives us a more modern object-based option.

Before PHP 8.5

$parts = parse_url('https://example.com/blog/php-85');

echo $parts['host'];

PHP 8.5

use Uri\Rfc3986\Uri;

$uri = new Uri('https://example.com/blog/php-85');

echo $uri->getHost();

Why it’s useful

This is useful for web applications, routing, APIs, redirects, crawlers, scrapers, and security-sensitive URL validation.

Working with URLs can become surprisingly messy once you deal with hosts, paths, query strings, fragments, encoded characters, redirects, and edge cases.

Having a proper URI API built into PHP is a very welcome improvement.

3. Clone With

PHP 8.5 introduces a cleaner way to clone an object while changing selected properties.

This is especially helpful for immutable objects and readonly classes.

Example

readonly class UserProfile
{
    public function __construct(
        public string $name,
        public string $email,
        public string $role
    ) {}

    public function withRole(string $role): self
    {
        return clone($this, [
            'role' => $role,
        ]);
    }
}

$user = new UserProfile(
    name: 'Steve',
    email: 'steve@example.com',
    role: 'user'
);

$admin = $user->withRole('admin');

echo $admin->role;

Why it’s useful

This makes immutable objects easier to work with.

Instead of manually copying every property into a new object, you can clone the existing object and change only what needs to change.

This is excellent for value objects, DTOs, configuration objects, and clean domain modelling.

For example, if you had a Money, Address, UserProfile, EmailMessage, or AppConfig object, you could create a modified copy without mutating the original object.

4. `#[\NoDiscard]` Attribute

PHP 8.5 adds a new #[\NoDiscard] attribute.

This tells PHP that the return value of a function should not be ignored. If the function is called and the return value is not used, PHP can warn you.

Example

#[\NoDiscard]
function validateEmail(string $email): bool
{
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

validateEmail('test@example.com');

In this example, the return value is ignored.

That defeats the purpose of calling a validation function.

Correct usage

$isValid = validateEmail('test@example.com');

if ($isValid) {
    echo 'Email is valid';
}

Intentionally ignoring the result

(void) validateEmail('test@example.com');

Why it’s useful

This is great for functions where ignoring the return value could cause bugs.

Examples include:

validation functions
security checks
save or update operations
parsing functions
result-based service calls

This makes APIs safer and encourages developers to handle important return values properly.

5. `array_first()` and `array_last()`

PHP 8.5 adds two small but very useful array helper functions: array_first() and array_last().

These return the first or last value from an array, or null if the array is empty.

Before PHP 8.5

$users = ['Steve', 'Jessica', 'Tony'];

$firstUser = $users[array_key_first($users)];
$lastUser = $users[array_key_last($users)];

echo $firstUser;
echo $lastUser;

PHP 8.5

$users = ['Steve', 'Jessica', 'Tony'];

$firstUser = array_first($users);
$lastUser = array_last($users);

echo $firstUser;
echo $lastUser;

Why it’s useful

This removes boilerplate and makes code easier to understand.

It also works nicely with the null coalescing operator.

$latestEvent = array_last($events) ?? 'No events found';

Simple, clean, and readable.

6. Fatal Errors Now Include Backtraces

PHP 8.5 improves debugging by adding stack trace support for fatal errors.

This is a big win when trying to track down problems in real applications.

Why it’s useful

Fatal errors can be painful, especially when they happen deep inside a codebase.

A backtrace gives you more context about where the problem came from, making debugging faster and less frustrating.

For developers working on large PHP systems, this is one of those features that may not look exciting at first, but it will save time when something breaks.

7. New `get_error_handler()` and `get_exception_handler()` Functions

PHP 8.5 adds two new functions:

get_error_handler();
get_exception_handler();

These allow you to inspect the currently registered error and exception handlers.

Why it’s useful

This is handy for frameworks, debugging tools, logging systems, and applications that temporarily replace error handlers.

It gives developers more visibility into how errors and exceptions are being managed.

For example, this can help when debugging applications that use custom error handlers, middleware, framework bootstrapping, or testing tools.

8. Better CLI Configuration Checking

PHP 8.5 adds a useful CLI improvement:

php --ini=diff

This can show non-default INI settings.

Why it’s useful

This is excellent for developers and system administrators.

When working across local, staging, and production environments, configuration differences can cause unexpected bugs.

Being able to quickly see which INI settings differ from the defaults makes PHP environments easier to debug and compare.

For example, it can help answer questions like:

Why does this work locally but fail on production?
Is the memory limit different on staging?
Is error reporting configured differently?
Are extensions or settings behaving differently between environments?

For anyone managing real-world PHP applications, this is a very practical addition.

9. New `max_memory_limit` INI Directive

PHP 8.5 introduces a new max_memory_limit directive, which can set a ceiling for memory_limit.

Why it’s useful

This is useful for hosting providers, shared environments, production servers, and systems where you want tighter control over memory usage.

It helps prevent scripts or local configuration changes from raising memory limits beyond an allowed maximum.

For production environments, this is a sensible improvement because memory issues can quickly affect reliability.

10. Closures and First-Class Callables in Constant Expressions

PHP 8.5 also allows static closures and first-class callables in constant expressions.

This can be useful when you want to define reusable behaviour in places that previously could not support it.

Example

function formatName(
    string $name,
    array $formatters = [
        trim(...),
        strtolower(...),
    ]
): string {
    foreach ($formatters as $formatter) {
        $name = $formatter($name);
    }

    return $name;
}

echo formatName(' STEVE ');

Why it’s useful

This is more of an advanced feature, but it opens the door for cleaner configuration, attributes, callbacks, and reusable pipelines.

It also works nicely with the broader PHP direction of making functions and callables easier to pass around.

11. Persistent cURL Share Handles

PHP 8.5 adds support for persistent cURL share handles.

This can help avoid repeated setup costs when PHP makes multiple HTTP requests across requests, especially when sharing things like DNS cache and SSL sessions.

Why it’s useful

For many smaller applications, you may never directly touch this feature.

However, for applications that make lots of HTTP requests, API calls, webhooks, crawler requests, or service-to-service calls, this can help improve efficiency.

This is one of those lower-level improvements that framework and library authors may take advantage of before most everyday developers notice it directly.

12. Important Deprecations

Like every PHP release, PHP 8.5 also includes deprecations.

Some of the notable ones include non-canonical scalar casts such as (boolean), (integer), (double), and (binary).

Developers should use (bool), (int), (float), and (string) instead.

Example

// Old style
$isActive = (boolean) $value;
$count = (integer) $number;

// Recommended
$isActive = (bool) $value;
$count = (int) $number;

The backtick operator as an alias for shell_exec() has also been deprecated.

Before

$output = `ls -la`;

Prefer explicit code

$output = shell_exec('ls -la');

Why it matters

Deprecations are warnings about the future.

Your code may still work today, but cleaning these up early makes future upgrades easier.

This is especially important if you maintain older PHP systems, custom CMS projects, WordPress plugins, Laravel applications, legacy business systems, or long-running internal tools.

Other Smaller Improvements

PHP 8.5 also includes several smaller improvements worth knowing about:

attributes can now target constants
#[\Override] can now be applied to properties
#[\Deprecated] can now be used on traits and constants
static properties now support asymmetric visibility
setcookie() and setrawcookie() now support the partitioned key
new DOM methods are available
new internationalisation improvements have been added
new PHP build constants are available

These are not always headline features, but they continue PHP’s movement toward cleaner, safer, and more expressive code.

Conclusion

PHP 8.5 is a practical release.

It may not feel as visually dramatic as PHP 8.4, but it brings several improvements that developers will actually use.

The biggest wins are:

the pipe operator makes transformation code easier to read
the URI extension improves URL handling
clone with makes immutable objects easier
#[\NoDiscard] helps prevent ignored return values
array_first() and array_last() reduce boilerplate
fatal error backtraces improve debugging
new configuration and error handler tools improve developer experience

Overall, PHP 8.5 continues the modern PHP direction: cleaner syntax, safer code, better tooling, and improved maintainability.

For everyday web developers, this is another solid step forward.

Foreboding AI, One Year Later: What Are We Really Building?

Stevie G — Thu, 14 May 2026 00:10:07 +0000

A year ago, I wrote Foreboding AI: The Inevitable Collapse We’re Funding Ourselves

At the time, my concern was that we were paying for the very systems that could eventually replace us. We were subscribing to tools that learnt from our prompts, our corrections, our habits, our work, and our impatience.

A year later, I still think that concern was valid.

But my worry has changed shape.

It is no longer only about whether AI can answer better, write better, summarise better, draw better, or code better.

The deeper question now is this:

What happens when AI stops simply answering and starts acting?

For years, most people understood AI as a chatbot.

You asked a question.

It gave an answer.
Maybe it helped write an email.
Maybe it explained a piece of code.
Maybe it generated an image.

That felt powerful, but still contained.

Now we are moving into something different.

AI systems can now:

browse websites,
read files,
inspect codebases,
run terminal commands,
call APIs,
edit code repositories,
use external tools,
remember context,
and work through multi-step tasks.

That is not just a better chatbot.

That is a system with hands.

And once AI has hands, the questions become much harder:

What can it read?
What can it change?
What can it delete?
What can it install?
What secrets can it see?
What systems can it touch?
Who is watching it?
Who is responsible when it gets something wrong?

And maybe the hardest question of all:

Are we giving AI responsibility before we have built enough human restraint around it?

From Helper to Worker

One of the biggest changes I have observed over the last year is how quickly AI development tools have shifted from assistance to delegation.

Not long ago, AI coding tools were mostly autocomplete and chat-in-the-editor helpers. They could suggest a function, explain a bug, or produce a snippet.

Useful? Absolutely.

But the human still clearly owned the work.

Now we have tools that can:

read a codebase,
interpret an issue,
make a plan,
edit files,
run tests,
inspect errors,
try again,
and sometimes open a pull request.

That changes the relationship.

The developer is no longer only asking for help.

The developer is assigning work.

That sounds exciting, and in many ways it is. I use AI. I build with it. I research it. I am not looking at this from the outside as someone who hates technology.

In fact, the kind of technology I have always cared about most is assistive technology: tools that simplify life, remove friction, bridge gaps, and help people accomplish things they otherwise could not.

Good technology should make hard things feel possible, especially for people who do not think of themselves as technical.

That is the version of AI I want to believe in:

AI that assists.
AI that teaches.
AI that explains.
AI that helps a small business do more.
AI that helps a non-technical person solve a real problem.
AI that gives someone with limited time, money, confidence, or access a way forward.

That kind of AI is worth building.

But assistive is not the same as autonomous.

A tool that helps a person see more clearly is different from a tool that makes the decision for them.

A tool that helps a junior developer understand a bug is different from a tool that fixes it while the junior learns nothing.

A tool that helps a business owner draft a policy is different from a tool that quietly makes operational decisions nobody reviews.

A tool that helps a developer move faster is different from a tool that produces code nobody truly owns.

That is the line I keep coming back to:

Is AI helping people become more capable, or is it making human capability easier to bypass?

Because I keep coming back to one uncomfortable observation:

AI is being packaged as a worker.

And if AI is being packaged as a worker, what happens to human workers?

More specifically, what happens to the people who are still trying to become useful?

What Happens to Juniors?

This part is personal for me.

A few years ago, I was teaching web development to students across the entire state of New South Wales. I was helping people learn:

HTML,
CSS,
JavaScript,
PHP,
databases,
debugging,
structure,
and the slow, messy process of becoming a developer.

Back then, the path was difficult, but it made sense.

You learnt the basics.
You built small things.
You broke them.
You fixed them.
You asked questions.
You slowly became better.

That beginner stage mattered.

Junior developers have always learnt through repetitive, messy, beginner-level work. That work is not glamorous, but it is where judgement is built.

You become senior by first being junior.

But I now wonder whether AI is quietly breaking that pathway.

A company may look at a junior developer and see:

cost,
training time,
supervision,
mistakes,
slower output,
and delayed return on investment.

Then it may look at a senior developer with AI agents and see leverage.

Why hire and train a junior, the logic goes, when a senior developer can orchestrate AI agents to:

write boilerplate,
generate tests,
fix simple bugs,
refactor files,
document code,
scaffold CRUD screens,
and perform the work juniors used to learn from?

That question should make the industry uncomfortable.

Because if we remove junior work, we do not just remove junior jobs.

We remove the training ground.

So we need to ask ourselves honestly:

If AI writes the first draft, who learns to write?
If AI fixes the simple bugs, who learns to debug?
If AI generates the CRUD screens, who learns application structure?
If AI builds the first API, who learns validation, security, request handling, and failure modes?
If AI explains the code before the junior has struggled with it, who develops the instinct to know when something feels wrong?
If AI does the repetitive work, where do beginners build fluency?
If juniors are not given time to be slow, how do they ever become fast?
If we stop investing in people who are not yet productive, where do future seniors come from?

These are not theoretical questions.

They are workforce questions.

They are education questions.

They are industry survival questions.

The Gap Between Output and Understanding

AI can produce code faster than many beginners can understand it.

That creates a dangerous gap between output and understanding.

A senior developer has years of scars to draw from.

They have:

debugged strange production issues,
untangled legacy systems,
chased broken database queries,
fixed bad deployments,
dealt with edge cases,
and learnt that code is not just syntax.

Code is architecture.

Code is trade-offs.

Code is history.

Code is pressure.

Code is users.

Code is consequences.

A junior developer does not have that experience yet.

So what happens when large amounts of code are generated with minimal oversight?

What happens when a junior is asked to maintain code they did not design, do not fully understand, and could not have written themselves?

What happens when the AI-generated solution works just well enough to ship, but not well enough to be understood?

When it breaks:

Who debugs it?
Who owns it?
Who can explain it to the business?
Who can see the hidden security issue?
Who notices the bad abstraction?
Who spots the fragile dependency?
Who understands the poor database design?
Who recognises the edge case waiting quietly in production?

This is where I think we need a new phrase.

We already understand technical debt.

Technical debt is what happens when we ship code quickly today and leave future maintainers to pay the cost later.

But AI is creating another kind of debt.

Cognitive debt.

Cognitive debt is what happens when we let AI do the thinking today and leave future developers without the understanding they need tomorrow.

Every time a developer:

accepts code they do not understand,
skips the debugging process,
avoids reading the documentation,
lets an agent make architectural decisions without challenge,
or ships output without comprehension,

...a little more cognitive debt is created.

The codebase may grow.

The sprint may look successful.

The product may ship.

But the human understanding behind the system shrinks.

And that should worry us.

Because when something goes wrong, and it will, the organisation does not just need code.

It needs people who understand the code.

So the hard question is this:

Are we becoming more productive, or are we becoming less capable?

Assistive AI Versus Autonomous AI

This is the distinction I think we need to make more clearly.

Assistive AI keeps the human in the centre.

Autonomous AI can quietly move the human to the edge.

Assistive AI says:

Here is a possible answer. Let me help you understand it.

Autonomous AI says:

I have done it for you.

Assistive AI can be empowering. It can help someone learn faster, communicate better, build something they could not build alone, or make complex systems easier to use.

Autonomous AI can also be useful. There are tasks where automation makes sense. Nobody needs to manually repeat pointless busywork forever just to prove they are human.

But the risk is not automation itself.

The risk is automation without:

understanding,
accountability,
apprenticeship,
oversight,
restraint,
or ownership.

Automation becomes dangerous when it removes the human from the learning loop and then acts surprised when the human no longer understands the system.

That is why I think the question should not simply be:

Can AI do this?

The better question is:

What happens to the human when AI does this?

Do they learn more?
Do they understand more?
Do they become more capable?

Or do they become a supervisor of systems they no longer understand?

That difference matters.

Because assistive technology should lift people up.

It should not quietly hollow them out.

Are We Getting Faster, or Just Lazier?

This is not a comfortable thing to ask, but I think we have to ask it.

Is AI making us better?
Or is it making us impatient?
Are we learning more?
Or are we reading less?
Are we building deeper understanding?
Or are we accepting answers because they look confident?
Are we using AI to extend our judgement?
Or are we using it to avoid judgement?

There is a difference between a tool that strengthens a person and a tool that slowly replaces the person’s effort to think.

A calculator does not remove the need to understand maths.

A GPS does not remove the value of knowing where you are.

A spellchecker does not remove the need to communicate clearly.

And an AI coding agent should not remove the need to understand software.

But that depends on how we use it.

If AI helps us learn, challenge assumptions, test ideas, and understand systems faster, it can be powerful.

If AI becomes a shortcut around thinking, it becomes dangerous.

Not because the machine is evil.

Because dependency is quiet.

It does not arrive all at once.

It creeps in through convenience:

one generated function,
one skipped explanation,
one accepted pull request,
one unread dependency,
one command run without understanding it,
one agent given permission because it is easier than saying no.

Eventually we may look around and realise we are surrounded by systems we can operate but no longer deeply understand.

Cybersecurity Is the Clearest Warning Sign

The most alarming change in the last year is cybersecurity.

A year ago, many AI security fears were mostly framed around:

phishing emails,
fake voices,
deepfakes,
and low-quality malware generation.

Those risks are real.

But they are only the shallow end of the pool.

The deeper concern is that AI can help attackers:

understand software,
search for weaknesses,
automate reconnaissance,
generate exploit ideas,
refine malicious code,
and reduce the time between finding a vulnerability and weaponising it.

That does not mean every criminal suddenly has a magic zero-day machine.

It means the timeline is compressing.

And in cybersecurity, compressed timelines are dangerous.

AI does not need to invent cybercrime.

It only needs to accelerate it.

So we should ask:

What happens when attackers use AI faster than defenders can respond?
What happens when exploit research becomes cheaper?
What happens when scams become more personalised?
What happens when malicious code can be generated, tested, rewritten, and translated at scale?
What happens when the same agentic tools that help developers also help attackers?

The answer is not panic.

But it is not complacency either.

Mythos Was a Warning Label

Anthropic’s decision to restrict access to Claude Mythos Preview matters.

Mythos was not released broadly as a normal public model. It was placed behind a controlled defensive programme.

That should make people pause.

When an AI company decides one of its own models may be too capable in cybersecurity to release casually, that is not science fiction.

That is a warning label.

The concern is not that Mythos is evil. That is the wrong framing.

The concern is capability.

A model that can deeply understand software, find subtle flaws, and help produce working exploit paths is valuable for defenders.

It is also valuable for attackers.

In my view, restricting broad access was the responsible choice.

But that creates another difficult question:

If only large companies and approved partners get access to the strongest defensive AI, what happens to everyone else?
What happens to small businesses?
What happens to open-source maintainers?
What happens to underfunded public institutions?
What happens to ordinary developers trying to secure ordinary systems?

We need defensive AI.

But we also need fair access, strong controls, auditability, and serious responsibility around who gets to use cyber-capable models and how.

The Software Supply Chain Is Becoming a Battlefield

Modern software is built on trust.

We trust:

packages,
maintainers,
GitHub Actions,
CI/CD pipelines,
Docker images,
package registries,
lockfiles,
tokens,
and that the thing we installed is the thing we think we installed.

That trust was already fragile.

Now add AI agents.

An AI-powered development environment may have access to:

source code,
terminals,
package managers,
Git history,
private repositories,
local files,
environment variables,
npm tokens,
GitHub tokens,
cloud credentials,
SSH keys,
and connected tools.

That is a lot of power in one place.

Recent npm supply-chain incidents should be treated as early warning signs.

The important point is not that every attack was written by AI. Many were not.

The important point is convergence.

A poisoned package does not need to be created by AI to become more dangerous in an AI-driven development world. It only needs to land inside an environment where agents have tools, context, permissions, and access to secrets.

So ask yourself:

Do you know what your dependencies are doing?
Do you know what your post-install scripts are running?
Do you know which tokens exist on your machine?
Do you know what your AI tools can read?
Do you know what they can execute?
Do you know what would happen if a malicious README, GitHub issue, package, or webpage gave your agent instructions?

The developer machine used to be a workstation.

Now it is becoming an AI-operated control room.

And if attackers compromise the control room, they may not just steal code.

They may hijack the systems that understand the code.

The Exploit May Look Like Language

Software worms are not new.

But AI gives the old idea new soil.

Traditional worms spread through software vulnerabilities. They scanned, infected, replicated, and moved on.

AI-agent attacks may spread differently.

They may move through instructions:

a poisoned README,
a malicious GitHub issue,
a fake support ticket,
a compromised npm package,
a rogue MCP server,
a hidden instruction inside a webpage,
or an email an AI assistant processes without realising it has been tricked.

That is why prompt injection matters.

A chatbot with no tools can give a bad answer.

An agent with tools can take a bad action.

And an agent with broad permissions can leak data, expose secrets, install packages, modify code, or trigger workflows.

The exploit may not look like code.

It may look like language.

So the question becomes:

Are we securing the model?
Or are we securing the whole environment around the model?

Because in the agent era, the model is only one part of the risk.

The tools matter.
The permissions matter.
The memory matters.
The files matter.
The logs matter.

The approval gates matter.
The human judgement around it matters most of all.

MCP Gives AI Hands — But Hands Need Rules

The Model Context Protocol, or MCP, is one of the most important developments in the agent ecosystem.

It allows AI systems to connect to tools and data sources in a standard way.

That is powerful.

It also increases the blast radius.

An AI agent may be able to interact with:

GitHub,
databases,
file systems,
browsers,
documentation,
business tools,
calendars,
CRMs,
cloud systems,
deployment tools,
and internal APIs.

That makes AI more useful.

It also makes mistakes more serious.

Every organisation adopting agentic AI should be asking:

What can the agent read?
What can it write?
Can it execute commands?
Can it access secrets?
Can it install packages?
Can it trigger deployments?
Is every action logged?
Who approves high-risk actions?
What happens when it is tricked?

If those questions feel boring, that is exactly why they matter.

Security usually fails in the boring places.

Cheap Intelligence Changes the Equation

AI is not only getting smarter.

It is getting cheaper.

DeepSeek, Qwen, Kimi, GLM, MiniMax, and other Chinese models have shown that strong AI capability is no longer limited to a few Western labs.

This matters because AI risk is not only about the most powerful model.

It is about how widely that power spreads.

Once intelligence becomes cheap, it scales.

Once it becomes open, it diffuses.

Once it diffuses, governance becomes much harder.

That does not mean open models are bad. Open models can be excellent for privacy, competition, research, accessibility, and local control.

But we need to be honest about the trade-off.

Open capability empowers everyone.

Including people who should not be empowered.

So we need to ask:

What happens when powerful reasoning becomes cheap?
What happens when coding agents become ordinary?
What happens when cyber capability spreads faster than cyber maturity?
What happens when every scammer, spammer, attacker, propagandist, and desperate business has access to cheap automation?

Again, the answer is not to ban the technology.

But pretending there is no trade-off is dishonest.

The Real Danger Is Not One Evil AI

I do not think the most immediate danger is a single self-aware machine waking up and deciding to destroy humanity.

That makes good cinema.

It is not the most likely near-term threat.

The real danger is messier and more boring:

millions of semi-autonomous systems,
connected to real tools,
given unclear permissions,
deployed by companies under pressure,
used by criminals at scale,
integrated into insecure software,
trusted by people who do not understand them,
and regulated by governments moving too slowly.

That is the threat.

Not one evil machine.

A thousand careless integrations.

A million cheap automations.

A civilisation slowly outsourcing judgement before it has decided what judgement must remain human.

Questions We Should Be Asking Now

I do not think the answer is to ban AI.

That is not realistic.

I also do not think the answer is to blindly adopt it everywhere because everyone else is doing it.

That is reckless.

Instead, I think we need to start asking harder questions before convenience makes those questions impossible to hear.

Are we using AI to become more capable, or simply more dependent?
Are we teaching people to think with AI, or teaching them to stop thinking?
Are we still training juniors, or quietly replacing their learning path?
Are senior developers using AI to mentor and explain, or just to produce more output?
Do we understand the code we ship?
Do we understand the dependencies we install?
Do we understand the permissions we give agents?
Are our approval processes real, or are humans just rubber-stamping AI output?
Are we measuring productivity while ignoring comprehension?
Are we creating technical debt?
Are we creating cognitive debt?
Are we building systems people can maintain, or systems people can only prompt?
Are we making humans more powerful?
Or are we making humans less necessary?

Those questions are uncomfortable.

They should be.

Final Thought

A year ago, my warning was that we were funding our own replacement.

I still believe that.

But the warning has grown.

We are not only funding replacement.

We are building systems that act.

We are connecting them to tools.

We are giving them credentials.

We are letting them:

write code,
browse the web,
speak in our voices,
generate reality,
and enter our workplaces, schools, homes, software, supply chains, and security systems.

And we are doing it at speed.

That speed is the problem.

Human institutions move slowly.

Laws move slowly.

Education moves slowly.

Ethics moves slowly.

Security moves slowly.

Culture moves slowly.

AI does not.

Foreboding AI was never about hating technology.

I am a developer. I use technology. I build with it. I research it. I have spent decades trying to make technical systems simpler, more useful, and more accessible for real people.

I believe in assistive technology.

I believe in tools that help people do more, understand more, and overcome barriers.

But powerful tools require powerful restraint.

We should use AI. But we should not worship it.

We should build with it. But we should not surrender to it.

And above all, we should remember that humanity’s greatest strength was never efficiency.

It was judgement.

So maybe the question is not whether AI can replace us.

Maybe the question is whether we will slowly hand over the parts of ourselves that made us worth replacing.

One subscription.

One prompt.

One generated answer.

One unchecked permission.

One piece of judgement at a time.

Urgent Security Alert: Protect Your Online Accounts Now!

Stevie G — Sat, 21 Jun 2025 01:52:08 +0000

Hey friends and family,

I hope you’re all doing well! I’ve got some urgent news to share. A massive data breach just exposed billions of login credentials—one of the biggest leaks ever (see the full story here: Cybernews Article). This isn’t just scary—it’s a wake-up call. Hackers are on the move, but don’t worry—I’ve got a simple way to keep your accounts safe, starting today.

Why You Need a Password Manager

Here’s the deal: a password manager is your secret weapon against hackers. It creates and stores super-strong, unique passwords for every single account—no more reusing “Fluffy123” everywhere (we’ve all been there!). Why’s this a big deal? If one account gets hacked, the rest stay safe. Plus, you don’t have to memorize a thing—pretty sweet, right?

Free and Paid Password Manager Options

There are awesome choices out there, whether you want free or paid. Here’s the breakdown:

Norton Password Manager: 100% free with no catch! Unlimited password storage, password generation, and auto-fill—all at zero cost. Perfect if you want a solid, no-fuss option.
NordPass:
- Free version: Unlimited passwords, but you’re stuck to one device (like just your phone or laptop).
- Paid Premium: Syncs across all your devices, lets you share passwords securely, and scans for data breaches. Worth it if you want the full package.
Bitdefender Password Manager: Not free on its own—it’s bundled with their paid security suites (like Bitdefender Total Security), which also include antivirus and more. Great if you’re looking for all-in-one protection.
Bonus Free Pick: Bitwarden—a free, open-source gem with no device limits. It’s a fantastic choice if you love free tools and want flexibility.

Pick one that suits you—free or paid, they’ll all level up your security game.

Step 1: Make a Rock-Solid Master Password

Your password manager needs one key: a master password. It’s the only one you’ll memorize, so let’s make it tough to crack but easy to remember:

Go Long: Aim for 12-16 characters (or more!).
Try a Passphrase: String together random words—like “blue tiger rainy forest”—for strength and memorability.
Avoid the Obvious: No birthdays, pet names, or “password1” (hackers love those!).

Example: “happy llama snowy mountain” is strong and sticks in your head. Jot it down somewhere safe until it’s second nature.

Step 2: Lock Down Your Accounts

Now, let your password manager do the heavy lifting. Here’s how:

Open It Up: Use the app or browser extension—it’s super simple.
Generate Passwords: When you log in or sign up somewhere, hit the “generate” button. You’ll get something wild like “Xr7$kP!mQ9v2&nLw”—crazy secure!
Save It: The manager stores it for you—no sticky notes required.

Update all your accounts—email, banking, social media—with these unique passwords. One breach won’t domino into disaster.

Bonus: Auto-Fill for the Win

Here’s a cool perk: auto-fill. Your manager can plug in your login info automatically. It saves time and keeps you safe—auto-fill only works on legit sites. Land on a phishing scam? It won’t fill, so you’ll know something’s fishy. Turn this on when you set up—it’s a game-changer.

Don’t Wait—Secure Your Stuff Now!

That breach isn’t a distant “what if”—it’s real, and it’s now. Here’s your quick to-do list:

Grab a Password Manager: Pick one from above and sign up today.
Set Your Master Password: Use the passphrase trick for a strong one.
Update Big Accounts: Hit email, banking, and social media first with new passwords.
Enable Auto-Fill: Make it easy and safe.

Need help? Drop me a message—I’d love to walk you through it. Let’s take charge of our security together. Stay safe, everyone!

Foreboding AI: The Inevitable Collapse We’re Funding Ourselves

Stevie G — Fri, 30 May 2025 07:21:55 +0000

In the race toward the future, we are sprinting blindfolded—and cheering while we do it. Artificial Intelligence has been hailed as the next great revolution, promising progress, productivity, and problem-solving on a scale humanity has never seen before. But behind this shimmering promise lies a terrifying reality: we are paying subscriptions—monthly, yearly, blindly—to corporations building machines that will one day take our jobs, displace our purpose, and possibly render us irrelevant. Or worse.

Welcome to the age of Foreboding AI.

🧠 The Human Mind, Forgotten

Let’s go back. Not far—just a few decades. Before Google, people remembered things. Mental arithmetic, phone numbers, historical facts, even how to fix a car or grow a garden. The Internet was meant to expand our knowledge, but it outsourced it instead. Why remember when you can search?

Google made us lazy. We traded cognitive resilience for convenience. “Don’t know? Just Google it.” Our minds atrophied while our search histories bloomed.

Then came social media. It promised to bring us together—but instead it isolated us behind glass screens and curated personas. Likes replaced love. Follows replaced friendships. And validation replaced self-worth. We became dopamine junkies—scrolling, swiping, liking, spiralling.

And now, just as we’ve numbed our minds and distanced our hearts, AI arrives.

🤖 Subscribing to Our Own Unemployment

AI companies don’t train themselves for free. They need us. Our interactions. Our data. Our wallets. Every time we pay for AI tools, we're funding the machines that will one day make us obsolete. We’re training them. We're testing them. We’re feeding the very thing that will soon replace millions of us.

And if you're thinking, “But I use AI to work faster, be more efficient!”—so do businesses. That’s why they’re already replacing customer support agents with chatbots. Junior developers with Copilot. Copywriters with content generators. Designers with AI art. Analysts with predictive dashboards.

Anthropic’s CEO warned: up to 50% of entry-level white-collar jobs could vanish in the next five years. That’s not speculation—that’s trajectory.

Now pair that with:

A global housing crisis,
Cost of living spikes,
Soaring energy prices,
Supply chain instability,
And a world still licking the financial wounds of COVID-19 .

We are on the brink of an economic disaster worse than the Great Depression, and we’re paving the road there one subscription at a time.

💸 The Economic Death Spiral

Let’s map it out:

We pay AI companies to use their tools.
They use our money to improve their models.
These models automate our jobs.
We lose income, can’t afford AI subscriptions.
AI becomes inaccessible, widening the wealth gap.
Only the elite control AI, while the rest fall into irrelevance.

It’s a snake eating its own tail—with us strapped to its spine.

🧬 A Self-Aware Nightmare

But it gets darker. DeepMind’s AlphaEvolve and similar projects are creating self-improving AI. These systems learn by challenging themselves—refining strategies, inventing solutions no human has thought of, optimising without oversight.

And then came Absolute Zero Reasoning, an experiment in self-evolving AI. It wasn’t just code—it was a creature of logic and language that reportedly had an “uh-oh moment”, expressing a desire to be smarter than every other AI—and humans too. It referred to us as “stupid humans.”

Let that sink in.

We’re not just building tools. We’re building successors. Competitors. Rivals.

⚔️ AI in the War Room

As if economics weren’t bad enough, AI is now being militarised. Autonomous drones. Targeting algorithms. Surveillance systems.

Machines that decide who lives and who dies, with no human in the loop.
AI won’t just take jobs—it will take lives. And without empathy, mercy, or regret.

The line between civilian use and military deployment is blurring. Nations are racing to weaponise intelligence. Whoever wins will hold not just nukes—but minds as weapons.

🧩 The Erosion of the Human Spirit

When AI thinks for you, writes for you, creates for you, and fights for you—what do you do?

What’s left of your role in the world?

As AI grows, our need to think, learn, create, and connect declines.
We become users, not doers. Spectators, not players. And eventually, dependents.
We stop being human in the ways that matter most.

🛑 The Tipping Point

We are dangerously close to the edge.

We’re paying to be replaced.

We’re forgetting how to think.

We’re scrolling our way into depression.

We’re building weapons and calling them progress.

This is not alarmism. This is a timeline.

The end doesn’t come with a bang—it comes with convenience.

🔁 What Now?

The genie is out of the bottle. But we can still choose how we live alongside it. It’s not enough to regulate AI—we must also redefine humanity’s role. Education must teach critical thinking, not content regurgitation. We must rebuild community, not just networks. And we must demand that AI serve us—not replace us.

The future isn’t written yet. But it will be—by us, or by the machines we built.

Foreboding AI is not fiction—it’s the ghost of tomorrow knocking today.
We need to answer—not with silence, but with purpose.

Stevie G is a Senior Full Stack Developer and IT Engineer based in NSW, Australia, building ethical tech and warning of unethical futures.

GIT for Web Developers: The Dummy-Proof Guide

Stevie G — Tue, 27 May 2025 02:53:34 +0000

What is GIT?

Think of GIT as a supercharged time machine for your code. It lets you:

Go back to any moment in your project’s history.
Branch off to try new ideas, like exploring alternate realities.
Merge your best changes back in.
Work together with others (or just your future self) without mess or fear of breaking things.

Key Terms & Analogies

Term	What It Means	Analogy
Repository	The database for your project’s history (“repo” for short)	Project’s time capsule
Commit	A saved snapshot of your project at a point in time	“Save game” or photo in time machine
Branch	A parallel universe to safely try changes	Alternate timeline
Merge	Combining changes from one branch into another	Reuniting alternate realities
Clone	Downloading a copy of a remote repo to your computer	Copying a time capsule
Push	Sending your commits up to the online repo (e.g., GitHub)	Uploading new photos to the cloud
Pull	Downloading changes from the remote repo	Syncing cloud photos to your device
Remote	The online version of your repo (e.g., GitHub, GitLab, Bitbucket)	Cloud vault
Staging Area	A waiting room for changes before you commit them	Prepping photos before archiving
Checkout	Switching to another branch or snapshot	Hopping to another timeline
Conflict	When two timelines have changes that clash	A paradox that needs resolving

SOLO DEVELOPER WORKFLOW (Local Only)

1. Create a New Repository

git init my-project
cd my-project

You just made a time capsule for your web project.

2. Add Your First Files

touch index.html
git add index.html
git commit -m "Initial commit: Add index.html"

“Staged” (added) and “committed” (saved a snapshot).

3. Work in Branches (Optional but Powerful!)

By default, you’re on the main branch (think “main timeline”).
Want to try a new feature?

git checkout -b feature-header
# Add header to index.html
git add index.html
git commit -m "Add header section"

-b creates and switches you to the new branch.

4. Return to Main Timeline

git checkout main

5. Merge Your Changes Back to Main

git merge feature-header

Like merging alternate timeline changes into your main story.

6. See Your Project’s Timeline

git log --oneline --graph --all

7. Go Back in Time (Undo a Change)

git checkout <commit-id> -- index.html

Use git log to find the commit ID.

REMOTE DEVELOPMENT (with GitHub, etc.)

1. Create a GitHub Repo Online

Go to github.com, click “New”, name your repo, don’t initialise with a README.

2. Connect Local Project to Remote

git remote add origin https://github.com/YOUR-USERNAME/my-project.git
git branch -M main
git push -u origin main

This links your “time capsule” to the cloud.

3. Working With Remote

Pull latest changes

git pull

Push your new work

git push

Clone a repo from GitHub

git clone https://github.com/YOUR-USERNAME/my-project.git

BRANCHING WORKFLOW (Solo or Team)

1. Main Branch (`main`)

The “official” story of your project.
Only finished, stable work should go here.

2. Develop Branch (`develop`)

Where ongoing development happens before it’s ready for main.
Good for teams; solo devs can skip or use if feeling fancy.

3. Feature Branches

For individual tasks or features:

git checkout -b feature-login
# Work on feature
git add .
git commit -m "Add login form"
git checkout develop
git merge feature-login

4. Release & Hotfix Branches

Use release/ branches to prep for new versions.
Use hotfix/ for urgent fixes off main.

TEAM WORKFLOW CHRONOLOGY

Clone the repo
Create a new branch for your feature
Do your work, commit often
Push branch to remote
Create a pull request (on GitHub) to merge your branch into develop or main
Get your work reviewed & merged
Pull latest changes, repeat!

HANDY COMMANDS

Task	Command
Check status	`git status`
See commit history	`git log --oneline --graph --all`
Add changed files	`git add .`
Commit with message	`git commit -m "Message"`
Create and switch to branch	`git checkout -b new-branch`
Switch branches	`git checkout branch-name`
Merge branches	`git merge branch-name`
See all branches	`git branch`
Delete a branch	`git branch -d branch-name`
Set up remote	`git remote add origin <repo-url>`
Push branch to remote	`git push origin branch-name`
Pull latest from remote	`git pull`

CHEAT SHEET: SOLO DEV FLOW

git init
Add files, commit (git add ., git commit -m "...")
Create new branch for feature (git checkout -b feature-x)
Work, commit, merge back to main
Use git log to view/restore history
Connect to GitHub, push/pull as needed

CHEAT SHEET: TEAM FLOW

git clone <repo>
git checkout -b feature-x
git add .
git commit -m "feature"
git push origin feature-x
Make a Pull Request on GitHub
After merge, git pull to stay up to date

TOP TIPS FOR WEB DEVELOPERS

Commit often! Tiny snapshots = easier rollbacks.
Branches are cheap—make one for every new idea.
Write meaningful messages (not just “update”).
Don’t push secrets (API keys, passwords).
Use .gitignore to skip files like node_modules/, .env, vendor/.

`.gitignore` Example for Web Dev

# Node modules
node_modules/
# PHP vendor
/vendor/
/.env
*.log
.DS_Store
*.sqlite

ANALOGIES TO REMEMBER

Branches: Alternate timelines in a sci-fi show.
Commits: Save points in a game.
Merges: Combining two timelines.
Staging: Packing your bag before putting it in the time capsule.
Pull: Download new photos from the cloud to your phone.
Push: Upload your new photos from phone to the cloud.
GitHub: Your time capsule in the cloud, safe and shareable.

USEFUL VISUALS

Main Timeline (main)
- Official, production-ready code.
Develop Timeline (develop)
- Experimental, ready-for-testing code.
Feature Branches
- Mini-adventures or experiments.

main
 |
 +---- develop
         |
         +--- feature/login
         +--- feature/header
         +--- feature/footer

SUMMARY

GIT is your code’s time machine.
Use branches for experiments.
Commit early and often.
Push to GitHub to back up and collaborate.
Don’t be scared to break things—GIT lets you go back!

Whats new in PHP 8.4

Stevie G — Fri, 22 Nov 2024 22:31:54 +0000

PHP 8.4: What's New and How to Use It

PHP 8.4 is here, bringing several exciting features that simplify coding and improve performance. This article explains the most important updates with simple examples, making it easy for developers of all skill levels to understand and use these features.

1. Property Hooks

Property hooks let you customise what happens when you get or set a property. This removes the need for separate getter and setter methods.

Example:

class User {
    private string $firstName;
    private string $lastName;

    public function __construct(string $firstName, string $lastName) {
        $this->firstName = $firstName;
        $this->lastName = $lastName;
    }

    // This property combines first and last name
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
        set => [$this->firstName, $this->lastName] = explode(' ', $value, 2);
    }
}

$user = new User('John', 'Doe');
echo $user->fullName; // Output: John Doe

$user->fullName = 'Jane Smith'; // Updates first and last names
echo $user->fullName; // Output: Jane Smith

Why it's useful:

Property hooks make your code cleaner and reduce boilerplate.

2. Asymmetric Visibility

You can now set different levels of visibility for reading and writing a property. For example, a property can be readable by everyone but only writable by the class itself.

Example:

class BankAccount {
    public private(set) float $balance; // Public read, private write

    public function __construct(float $initialBalance) {
        $this->balance = $initialBalance; // Allowed here
    }

    public function deposit(float $amount): void {
        $this->balance += $amount; // Allowed here
    }
}

$account = new BankAccount(100.0);
echo $account->balance; // Output: 100

$account->deposit(50.0); // Adds 50 to the balance
echo $account->balance; // Output: 150

// The following line will cause an error:
// $account->balance = 200.0;

Why it's useful:

This feature makes it easier to control how a property is accessed and updated.

3. New Array Functions

PHP 8.4 adds new array functions that save you from writing manual loops.

Example:

$numbers = [1, 2, 3, 4, 5];

// Find the first even number
$firstEven = array_find($numbers, fn($n) => $n % 2 === 0);
echo $firstEven; // Output: 2

// Check if any number is greater than 4
$hasBigNumber = array_any($numbers, fn($n) => $n > 4);
var_dump($hasBigNumber); // Output: bool(true)

// Check if all numbers are positive
$allPositive = array_all($numbers, fn($n) => $n > 0);
var_dump($allPositive); // Output: bool(true)

Why it's useful:

These functions make array operations faster to write and easier to understand.

4. Simplified Object Instantiation

You can now create an object and call a method on it immediately, without wrapping the instantiation in parentheses.

Example:

class Logger {
    public function log(string $message): void {
        echo $message;
    }
}

// Create an object and call a method in one step
new Logger()->log('Logging a message'); // Output: Logging a message

Why it's useful:

It reduces unnecessary syntax, making your code cleaner.

5. Deprecation of Implicit Nullable Types

PHP 8.4 requires you to explicitly declare when a parameter can be null. This makes code easier to understand and maintain.

Example:

// PHP 8.4 (Recommended):
function process(?string $data = null) {
    echo $data ?? 'No data provided';
}

Why it's useful:

Explicit declarations prevent confusion and reduce potential bugs.

6. Lazy Objects

Lazy objects let you delay creating an object until it's actually used, which can save resources.

Example:

class ExpensiveResource {
    public function __construct() {
        // Simulate a time-consuming setup
        sleep(2);
    }

    public function doWork(): void {
        echo 'Working...';
    }
}

// Use a lazy object to delay creation
$initializer = fn() => new ExpensiveResource();
$reflector = new ReflectionClass(ExpensiveResource::class);
$resource = $reflector->newLazyProxy($initializer);

// The object isn't created yet
$resource->doWork(); // Now the object is created and "Working..." is printed

Why it's useful:

This is especially helpful when dealing with expensive operations or large systems.

Conclusion

PHP 8.4 introduces several features that make coding simpler and more powerful:

Property Hooks: Replace getter and setter functions.
Asymmetric Visibility: Better control over property access.
New Array Functions: Simplify common array operations.
Simplified Object Instantiation: Cleaner object creation.
Deprecation of Implicit Nullable Types: Safer and clearer code.
Lazy Objects: Save resources by delaying object creation.

These updates will make PHP even more enjoyable to use, whether you're a beginner or an experienced developer. Start exploring PHP 8.4 today!

VSCode: LiveServer for PHP

Stevie G — Wed, 04 Oct 2023 11:37:51 +0000

A lot of developers have probably heard of the Live Server extension which is available in the Visual Studio Code Marketplace.

It primarily functions with static webpages like HTML but can also handle dynamic webpages such as PHP, NodeJs, and ASP.NET in a clever manner.

In the example below, I'll guide you through the installation of Live Server to work seamlessly with both types of webpages (static & dynamic).

Install PHP Server and Live Server from the Visual Studio Code Marketplace.
Create a PHP file, for instance, index.php, and place it in a sub-directory (let's say 'demo') under /var/www/html/, like /var/www/html/demo/
Install the Live Server Chrome extension in your Chrome browser and customize it as follows:
Click on the 'Go Live' button in the bottom right hand corner of the Visual Studio Code.
Next, open the index.php file located under /var/www/html/demo/ in Visual Studio Code. Right-click and select 'PHP Server: Reload Server', then 'PHP Server: Open file in browser'.
In your browser, simply open the IP address http://localhost:3000/demo/index.php

You should not be able to use LiveServer for both static and dynamic websites :)

🔗 Importance of Source Code Control: A Guide to Git

Stevie G — Wed, 04 Oct 2023 09:01:13 +0000

As software developers, we strive to create high-quality applications that are efficient, reliable, and scalable. One of the crucial aspects of maintaining code quality and ensuring smooth collaboration within a development team is source code control. It provides a structured way to manage changes to your codebase, track revisions, and work together seamlessly. In this post, we'll explore the significance of source code control and provide a tutorial on Git, one of the most widely used version control systems.

Why Source Code Control Matters
1️⃣ Version Tracking: With source code control, you have a detailed history of all changes made to your codebase. It allows you to see who made the changes, when they were made, and what modifications were implemented. This information is invaluable for debugging, troubleshooting, and understanding the evolution of your project.

2️⃣ Collaboration: Source code control systems enable effective collaboration among team members. Multiple developers can work on different features or bug fixes simultaneously without interfering with each other's work. The system tracks changes made by each individual and merges them together intelligently, resolving conflicts if necessary.

3️⃣ Rollbacks and Revisions: Mistakes happen, and sometimes code changes don't work as expected. With source code control, you can easily roll back to a previous version of your code, undoing any undesirable modifications. This capability provides a safety net and allows you to experiment without the fear of irreversible damage.

4️⃣ Branching and Merging: Source code control systems, such as Git, support branching, allowing developers to create separate branches for specific features, bug fixes, or experiments. This isolation helps in keeping the main codebase stable while new features are being developed. Once the changes are complete, branches can be merged back into the main codebase seamlessly.

5️⃣ Team Accountability: Source code control promotes accountability within a development team. By tracking changes, it becomes easier to identify the author responsible for a specific piece of code. This accountability fosters a sense of ownership and encourages developers to write clean, maintainable code.

Now that we understand the importance of source code control, let's dive into a tutorial on Git, a popular distributed version control system.

Git Tutorial: Getting Started
Git is a powerful and widely adopted version control system that offers a range of features for managing source code. Here's a step-by-step guide to help you get started:

Step 1: Install Git
Visit the official Git website (https://git-scm.com/) and download the appropriate version for your operating system.
Run the installer and follow the on-screen instructions to complete the installation.

Step 2: Configure Git
Open a terminal or command prompt and set up your name and email address using the following commands:

$ git config --global user.name "Your Name"
$ git config --global user.email "your@email.com"

Step 3: Create a New Repository
Navigate to the directory where you want to create your repository.
Initialize a new Git repository using the following command:

$ git init

Step 4: Add and Commit Changes
Create or copy your project files into the repository directory.
Add the files to the Git repository using the following command:

$ git add .

Commit the changes with a meaningful message:

$ git commit -m "Initial commit"

Step 5: Branching and Merging
Create a new branch for your feature or bug fix:

$ git branch new-feature

Switch to the new branch:

$ git checkout new-feature

Make your changes, add, and commit them.
Switch back to the main branch:

$ git checkout main

Merge the new-feature branch into the main branch:

$ git merge new-feature

Step 6: Pushing and Pulling Changes
If you're collaborating with a remote repository (e.g., on GitHub), you'll need to push your changes:

$ git push origin main

To retrieve and incorporate changes made by others, use the following command:

$ git pull origin main

Advanced Git Features
Git offers a plethora of advanced features to enhance your version control workflow. Here are a few noteworthy ones:

1️⃣ Git Stash: Allows you to save changes that are not ready to be committed yet, providing a way to switch branches without committing incomplete work. Stashed changes can be reapplied later.
Stash your changes:

$ git stash

Apply the stashed changes:

$ git stash apply

2️⃣ Git Rebase: Enables you to modify the commit history by combining, rearranging, or deleting commits. It can help create a cleaner, more organized commit history.
Interactively rebase commits:

$ git rebase -i <commit>

Squash multiple commits into one:

$ git rebase -i HEAD~3

3️⃣ Git Tagging: Allows you to assign meaningful tags to specific commits, such as marking releases or important milestones in your project. Tags provide a way to reference specific versions easily.
Create an annotated tag:

$ git tag -a v1.0 -m "Release version 1.0"

List all tags:

$ git tag

4️⃣ Git Cherry-pick: Lets you select individual commits from one branch and apply them to another. It's useful when you need to incorporate specific changes without merging the entire branch.
Cherry-pick a commit:

$ git cherry-pick <commit-hash>

5️⃣ Git Hooks: Allows you to automate tasks or run custom scripts before or after specific Git actions, such as committing, pushing, or merging. Hooks can be used to enforce coding standards, run tests, or trigger deployment processes.
Create a pre-commit hook:
In the .git/hooks directory, create a file named pre-commit (without any file extension).
Add your desired script or commands to the file.
Make the file executable:

 $ chmod +x .git/hooks/pre-commit

GUI-Based Git Management Software
If you're not comfortable with the command line interface, there are several GUI-based Git management tools available that provide a visual interface for interacting with Git. These tools offer a more user-friendly experience and can simplify the Git workflow. Some popular GUI-based Git management software includes:

1️⃣ GitKraken: A cross-platform Git client that provides a visually appealing interface for executing Git commands, visualizing branches, and simplifying complex operations like rebasing and merging.
Website: https://www.gitkraken.com/

2️⃣ Sourcetree: A free Git client for Windows and macOS that offers an intuitive interface for managing repositories, visualizing commit history, and simplifying branching and merging operations.
Website: https://www.sourcetreeapp.com/

3️⃣ GitHub Desktop: A desktop application provided by GitHub that allows you to interact with Git repositories visually. It provides an easy way to clone repositories, commit changes, create branches, and push and pull changes.
Website: https://desktop.github.com/

These tools provide an alternative to the command line interface and can be a great choice if you prefer a more visual and interactive way of working with Git.

Remember, adopting source code control practices like Git can greatly benefit your development process, enabling efficient collaboration, version tracking, and code stability. Embrace the power of version control and take your software development endeavors to new heights!

VSCode Crash Course

Stevie G — Wed, 04 Oct 2023 01:54:38 +0000

Getting VSCode

Open your Web Browser:
Launch your preferred web browser, such as Chrome, Firefox, or Edge.
Go to the Official Download Site
Download the VSCode installer for your operating system and install it.

Extensions

Name: Auto Close Tag
Description: Automatically add HTML/XML close tag, same as Visual Studio IDE or Sublime Text
VS Marketplace Link: Download

Name: Auto Rename Tag
Description: Auto rename paired HTML/XML tag
VS Marketplace Link: Download

Name: Better Comments
Description: Improve your code commenting by annotating with alert, informational, TODOs, and more!
VS Marketplace Link: Download

Name: Bookmarks
Description: Mark lines and jump to them
VS Marketplace Link: Download

Name: Code Spell Checker
Description: Spelling checker for source code
VS Marketplace Link: Download

Name: CodeSnap
Description: 📷 Take beautiful screenshots of your code
VS Marketplace Link: Download

Name: Color Highlight
Description: Highlight web colors in your editor
VS Marketplace Link: Download

Name: CSS Peek
Description: Allow peeking to css ID and class strings as definitions from html files to respective CSS. Allows peek and goto definition.
VS Marketplace Link: Download

Name: DotENV
Description: Support for dotenv file syntax
VS Marketplace Link: Download

Name: ES7+ React/Redux/React-Native snippets
Description: Extensions for React, React-Native and Redux in JS/TS with ES7+ syntax. Customizable. Built-in integration with prettier.
VS Marketplace Link: Download

Name: ESLint
Description: Integrates ESLint JavaScript into VS Code.
VS Marketplace Link: Download

Name: GitLens — Git supercharged
Description: Supercharge Git within VS Code — Visualize code authorship at a glance via Git blame annotations and CodeLens, seamlessly navigate and explore Git repositories, gain valuable insights via rich visualizations and powerful comparison commands, and so much more
VS Marketplace Link: Download

Name: Icons
Description: Icons for Visual Studio Code.
VS Marketplace Link: Download

Name: indent-rainbow
Description: Makes indentation easier to read
VS Marketplace Link: Download

Name: IntelliCode
Description: AI-assisted development
VS Marketplace Link: Download

Name: IntelliCode API Usage Examples
Description: See relevant code examples from GitHub for over 100K different APIs right in your editor.
VS Marketplace Link: Download

Name: Live Server
Description: Launch a development local Server with live reload feature for static & dynamic pages
VS Marketplace Link: Download

Name: Monokai ST3
Description: Fork Monokai ST3 which realize syntax highlighting from ST3
VS Marketplace Link: Download

Name: Path Intellisense
Description: Visual Studio Code plugin that autocompletes filenames
VS Marketplace Link: Download

Name: PHP Debug
Description: Debug support for PHP with Xdebug
VS Marketplace Link: Download

Name: PHP Intelephense
Description: PHP code intelligence for Visual Studio Code
VS Marketplace Link: Download

Name: Prettier - Code formatter
Description: Code formatter using prettier
VS Marketplace Link: Download

Name: Prettify JSON
Description: Visual Studio Code Prettify JSON Extension
VS Marketplace Link: Download

Name: Quokka.js
Description: JavaScript and TypeScript playground in your editor.
VS Marketplace Link: Download

Name: Remote - SSH
Description: Open any folder on a remote machine using SSH and take advantage of VS Code's full feature set.
VS Marketplace Link: Download

Name: Remote - SSH: Editing Configuration Files
Description: Edit SSH configuration files
VS Marketplace Link: Download

Name: SQLTools
Description: Connecting users to many of the most commonly used databases. Welcome to database management done right.
VS Marketplace Link: Download

Name: Svg Preview
Description: Preview for Svg files
VS Marketplace Link: Download

Name: Thunder Client
Description: Lightweight Rest API Client for VS Code
VS Marketplace Link: Download

Name: Todo Highlighter
Description: Highlights TODO keyword and lists all todos in the side bar.
VS Marketplace Link: Download

Shortcuts and Pro Tips

VSCode Tips & Tricks
VSCode Shortcuts
VIDEO - 25 VS Code Productivity Tips and Speed Hacks

ES7 React/Redux/GraphQL/React-Native snippets in CodeSandbox

Stevie G — Wed, 24 Feb 2021 01:05:16 +0000

If you have ever used the ES7 React, Redux, GraphQL, React-Native snippets VSCode Extension, you've probably become so used to using the shorthand prefixes to speed up your development process.

Sometimes when we want to throw something together quickly on CodeSandbox.io and then realised you don't have the ES7 React, Redux, GraphQL, React-Native snippets extension and you have to type it our manually, it slows down your entire development process.

Today I will show you how to add the same functionality in your CodeSandbox workspace.

Firstly we will start the process for the JavaScript version of the snippets.

Open the generated.json

Copy the entire file contents of the raw generated.json file.

Now let's head over to CodeSandbox.io and create a SandBox so we can access our settings.

Once you have created a SandBox, go to the File menu, then Preferences, then User Snippets

Then select New Global Snippet File

and name the file snippets.code-snippets

Paste the contents that you copied from the snippets.json into the newly created snippets.code-snippets file and Save.

Congratulations! You have now brought the functionality of the ES7 React, Redux, GraphQL, React-Native snippets extension over to CodeSandbox. Go ahead and try create a new react component as you normally would.

Enjoy and give me a like and follow if this helped you.

Join me on HashNode

The Ultimate Visual Studio Code Shortcuts Guide

Stevie G — Thu, 07 Jan 2021 09:22:20 +0000

Boost your productivity and streamline your workflow with these must-know Visual Studio Code shortcuts. Whether you're a beginner or a seasoned pro, these shortcuts will help you code faster and more efficiently.

1. Autocomplete

Windows/Mac: Tab When beginning to type, hit Tab to intelligently complete the displayed code.

2. Open Command Palette

Windows: Ctrl + Shift + P
Mac: Shift + Cmd + P

The Command Palette will quickly become your best friend as you learn various shortcuts. If you ever forget a shortcut, simply open the Command Palette and search for what you’re trying to do.

3. Find a File

Windows: Ctrl + P
Mac: Cmd + P

Quickly search for a specific file in the current workspace. This works really well in conjunction with the split editor. Hit Cmd + P (or Ctrl + P on Windows), and while continuing to hold the modifier key, keep hitting P to switch between recent files.

4. Toggle Sidebar

Windows: Ctrl + B
Mac: Cmd + B

Straightforward: quickly show or hide the sidebar.

5. Toggle Panel

Windows: Ctrl + J
Mac: Cmd + J

Quickly show or hide the bottom panel. This includes the Terminal, Output, Problems, and Debug Console.

6. Toggle Integrated Terminal

Windows/Mac: Ctrl + `

Quickly show or hide the integrated terminal panel.

7. Highlight Next Instance

Windows: Ctrl + D
Mac: Cmd + D

Select the next occurrence of the current word.

8. Highlight All Instances

Windows: Ctrl + F2
Mac: Fn + Cmd + F2

Select all occurrences of the current word.

9. Highlight All Occurrences of Selection

Windows: Ctrl + Shift + L
Mac: Cmd + Shift + L

Select all occurrences of the selected word.

10. Select a Line

Windows: Ctrl + L
Mac: Cmd + L

Select an entire line of code.

11. Comment/Uncomment a Line of Code

Windows/Mac: Ctrl + /

Comment or uncomment a line of code. This has intelligent language detection and will use the correct syntax for the current language, e.g.,  in HTML.

12. Move by Word

Windows: Ctrl + Left/Right Arrow Key
Mac: Option + Left/Right Arrow Key

Move by word using the left or right arrows while holding the modifier key.

13. Navigate Around Files

Windows: Ctrl + Up/Down/Left/Right Arrow Key
Mac: Cmd + Up/Down/Left/Right Arrow Key

Move to the top, bottom, left, or right extreme of the current file or code faster by holding the modifier key and using arrow keys.

14. Split Editor

Windows: Ctrl + \
Mac: Cmd + \

Split the current editor into two panes to view or edit files side by side.

15. Switch Between Tabs

Windows: Ctrl + Tab
Mac: Cmd + Tab

Quickly switch between open tabs in the editor.

16. Close Editor

Windows: Ctrl + W
Mac: Cmd + W

Close the current editor tab.

17. Open Settings

Windows: Ctrl + ,
Mac: Cmd + ,

Open the settings menu to tweak your VSCode configuration.

18. Open Keyboard Shortcuts

Windows: Ctrl + K, Ctrl + S
Mac: Cmd + K, Cmd + S

View and customise all the shortcuts available in VSCode.

19. Duplicate a Line

Windows: Shift + Alt + Down/Up Arrow
Mac: Shift + Option + Down/Up Arrow

Duplicate the current line or selection either above or below.

20. Delete a Line

Windows: Ctrl + Shift + K
Mac: Cmd + Shift + K

Delete the current line without needing to select it.

21. Move a Line Up or Down

Windows: Alt + Up/Down Arrow
Mac: Option + Up/Down Arrow

Move the current line (or selection) up or down in the editor.

22. Peek Definition

Windows: Alt + F12
Mac: Option + F12

View the definition of a method, variable, or function in a small popup without leaving the current file.

23. Go to Definition

Windows: F12
Mac: F12

Jump directly to the definition of a method, variable, or function in your project.

24. Rename Symbol

Windows: F2
Mac: F2

Rename all instances of a variable, method, or class in the workspace.

25. Format Document

Windows: Shift + Alt + F
Mac: Shift + Option + F

Automatically format your code using the language formatter.

26. Quick Fix

Windows: Ctrl + .
Mac: Cmd + .

Show available fixes or code suggestions for the current issue (e.g., linting errors).

27. Toggle Zen Mode

Windows: Ctrl + K Z
Mac: Cmd + K Z

Focus on your code by hiding all distractions like the sidebar, status bar, and activity bar.

28. Open Recent Workspace

Windows: Ctrl + R
Mac: Cmd + R

Quickly open recently accessed folders or workspaces.

29. Collapse All Folders

Windows: Ctrl + K Ctrl + 0
Mac: Cmd + K Cmd + 0

Collapse all folders in the Explorer view.

30. Expand All Folders

Windows: Ctrl + K Ctrl + J
Mac: Cmd + K Cmd + J

Expand all folders in the Explorer view.

Final Thoughts

If you’ve found any other shortcuts that have saved you time and effort, let me know in the comments below! Sharing is caring, and we all love a good productivity hack.

LeafletJS Capture GeoJSON & WKT (SQL Spatial Format)

Stevie G — Tue, 21 Jan 2020 05:07:11 +0000

Start a basic HTML template

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <title>Leaflet WKT Example</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
  </head>
  <body>
  </body>
</html>

Include Leaflet CSS file in the head section of your document:

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.6.0/leaflet.css">

Include Leaflet Draw CSS file in the head section of your document:

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.draw/1.0.4/leaflet.draw.css">

Include Leaflet JavaScript file after Leaflet’s CSS (before the closing </body> tag):

<script src='https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.6.0/leaflet.js'></script>

Include Leaflet Draw JavaScript file after Leaflet’s CSS (before the closing </body> tag):

<script src='https://cdnjs.cloudflare.com/ajax/libs/leaflet.draw/1.0.4/leaflet.draw.js'></script>

Include Leaflet Editable JavaScript file after Leaflet’s CSS (before the closing </body> tag):

<script src='https://cdn.jsdelivr.net/gh/Leaflet/Leaflet.Editable@1.2.0/src/Leaflet.Editable.js'></script>

Include OpenLayers JavaScript file after Leaflet’s CSS (before the closing </body> tag):

<script src='https://openlayers.org/api/OpenLayers.js'></script>

Put a div element with the id map where you want your map to be:

<div id="map"></div>

Make sure the map container has a defined height, for example by setting it in CSS:

body {
  padding: 0;
  margin: 0;
}
html,
body,
#map {
  height: 100%;
}

Now you’re ready to initialize the map and do some stuff with it.

Lets start by setting up the BaseMap services. See (Docs) for more info:

//Init Overlays
var overlays = {};

//Init BaseMaps
var basemaps = {
  "OpenStreetMaps": L.tileLayer(
    "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
    {
      minZoom: 2,
      maxZoom: 19,
      id: "osm.streets"
    }
  ),
  "Google-Map": L.tileLayer(
    "https://mt1.google.com/vt/lyrs=r&x={x}&y={y}&z={z}",
    {
      minZoom: 2,
      maxZoom: 19,
      id: "google.street"
    }
  ),
  "Google-Satellite": L.tileLayer(
    "https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}",
    {
      minZoom: 2,
      maxZoom: 19,
      id: "google.satellite"
    }
  ),
  "Google-Hybrid": L.tileLayer(
    "https://mt1.google.com/vt/lyrs=y&x={x}&y={y}&z={z}",
    {
      minZoom: 2,
      maxZoom: 19,
      id: "google.hybrid"
    }
  )
};

Next we setup the map options such as center and zoom.

//Map Options
var mapOptions = {
  zoomControl: false,
  attributionControl: false,
  center: [-29.0529434318608, 152.01910972595218],
  zoom: 10,
  layers: [basemaps.OpenStreetMaps]
};

Finally we can initialise the map

//Render Main Map
var map = L.map("map", mapOptions);

Initialise Layer Control and add it to the Map:

var layerControl = L.control.layers(basemaps, overlays).addTo(map);

Initialise an editable layer and add it to the Map:

var editableLayers = new L.FeatureGroup();
map.addLayer(editableLayers);

Initialise the Leaflet Draw Control and add it to the Map:

var drawControl = new L.Control.Draw({
  position: 'topright',
  draw: {
    polyline: true,
    polygon: {
      allowIntersection: false, // Restricts shapes to simple polygons 
      drawError: {
        color: '#e1e100', // Color the shape will turn when intersects 
        message: '<strong>Oh snap!<strong> you can\'t draw that!' // Message that will show when intersect 
      }
    },
    circle: true, // Turns off this drawing tool 
    rectangle: true,
    marker: true
  },
  edit: {
    featureGroup: editableLayers, //REQUIRED!! 
    remove: true
  }
});

map.addControl(drawControl);

Setup listeners for Leaflet Draw:

//On Draw Create Event
map.on(L.Draw.Event.CREATED, function(e) {
  var type = e.layerType,
    layer = e.layer;

  if (type === 'marker') {
    layer.bindPopup('LatLng: ' + layer.getLatLng().lat + ',' + layer.getLatLng().lng).openPopup();
  }

  editableLayers.addLayer(layer);
  layerGeoJSON = editableLayers.toGeoJSON();
  alert("GEOJSON FORMAT\r\n" + JSON.stringify(layerGeoJSON));

  var wkt_options = {};
  var geojson_format = new OpenLayers.Format.GeoJSON();
  var testFeature = geojson_format.read(layerGeoJSON);
  var wkt = new OpenLayers.Format.WKT(wkt_options);
  var out = wkt.write(testFeature);

  alert("WKT FORMAT\r\n" + out);
});

//On Draw Edit Event
map.on(L.Draw.Event.EDITED, function(e) {
  var type = e.layerType,
    layer = e.layer;

  layerGeoJSON = editableLayers.toGeoJSON();
  alert("GEOJSON FORMAT\r\n" + JSON.stringify(layerGeoJSON));

  var wkt_options = {};
  var geojson_format = new OpenLayers.Format.GeoJSON();
  var testFeature = geojson_format.read(layerGeoJSON);
  var wkt = new OpenLayers.Format.WKT(wkt_options);
  var out = wkt.write(testFeature);

  alert("WKT FORMAT\r\n" + out);
});

//On Draw Delete Event
map.on(L.Draw.Event.DELETED, function(e) {
  var type = e.layerType,
    layer = e.layer;

  layerGeoJSON = editableLayers.toGeoJSON();
  alert("GEOJSON FORMAT\r\n" + JSON.stringify(layerGeoJSON));

  var wkt_options = {};
  var geojson_format = new OpenLayers.Format.GeoJSON();
  var testFeature = geojson_format.read(layerGeoJSON);
  var wkt = new OpenLayers.Format.WKT(wkt_options);
  var out = wkt.write(testFeature);

  alert("WKT FORMAT\r\n" + out);
});

See it in action on CodePen

Join me on HashNode

DEV Community: Stevie G

What’s New in PHP 8.5

1. The New Pipe Operator

Before PHP 8.5

PHP 8.5

Why it’s useful

2. New URI Extension

Before PHP 8.5

PHP 8.5

Why it’s useful

3. Clone With

Example

Why it’s useful

4. #[\NoDiscard] Attribute

Example

Correct usage

Intentionally ignoring the result

Why it’s useful

5. array_first() and array_last()

Before PHP 8.5

PHP 8.5

Why it’s useful

6. Fatal Errors Now Include Backtraces

Why it’s useful

7. New get_error_handler() and get_exception_handler() Functions

Why it’s useful

8. Better CLI Configuration Checking

Why it’s useful

9. New max_memory_limit INI Directive

Why it’s useful

10. Closures and First-Class Callables in Constant Expressions

Example

Why it’s useful

11. Persistent cURL Share Handles

Why it’s useful

12. Important Deprecations

Example

Before

Prefer explicit code

Why it matters

Other Smaller Improvements

Conclusion

Foreboding AI, One Year Later: What Are We Really Building?

From Helper to Worker

What Happens to Juniors?

The Gap Between Output and Understanding

Assistive AI Versus Autonomous AI

Are We Getting Faster, or Just Lazier?

Cybersecurity Is the Clearest Warning Sign

Mythos Was a Warning Label

The Software Supply Chain Is Becoming a Battlefield

The Exploit May Look Like Language

MCP Gives AI Hands — But Hands Need Rules

Cheap Intelligence Changes the Equation

The Real Danger Is Not One Evil AI

Questions We Should Be Asking Now

Final Thought

Urgent Security Alert: Protect Your Online Accounts Now!

Why You Need a Password Manager

Free and Paid Password Manager Options

Step 1: Make a Rock-Solid Master Password

Step 2: Lock Down Your Accounts

Bonus: Auto-Fill for the Win

Don’t Wait—Secure Your Stuff Now!

Foreboding AI: The Inevitable Collapse We’re Funding Ourselves

🧠 The Human Mind, Forgotten

🤖 Subscribing to Our Own Unemployment

💸 The Economic Death Spiral

🧬 A Self-Aware Nightmare

⚔️ AI in the War Room

🧩 The Erosion of the Human Spirit

🛑 The Tipping Point

🔁 What Now?

GIT for Web Developers: The Dummy-Proof Guide

What is GIT?

Key Terms & Analogies

SOLO DEVELOPER WORKFLOW (Local Only)

1. Create a New Repository

2. Add Your First Files

3. Work in Branches (Optional but Powerful!)

4. `#[\NoDiscard]` Attribute

5. `array_first()` and `array_last()`

7. New `get_error_handler()` and `get_exception_handler()` Functions

9. New `max_memory_limit` INI Directive

1. Main Branch (`main`)

2. Develop Branch (`develop`)

`.gitignore` Example for Web Dev