Claude Fable 5 has quickly become one of the most talked-about AI model launches of the year — not because of benchmark results, coding ability, or developer enthusiasm, but because it was taken offline almost immediately after reported concerns around a possible jailbreak or safety bypass.

Anthropic’s most powerful new models, Claude Fable 5 and Mythos 5, are now at the centre of a fast-moving dispute involving model safety, government oversight, Amazon’s reported role in escalating concerns, and the practical question every developer is asking:

When is Claude Fable 5 coming back?

The latest focus is no longer simply the shutdown itself. It is the reported Washington meetings involving senior Anthropic technical staff. Those meetings could determine whether Fable 5 is treated as a model with a narrow, fixable safeguard issue — or whether the problem is considered serious enough to keep the model offline for longer.

That makes today potentially important. If Anthropic can demonstrate that the reported jailbreak has been patched, contained, or misunderstood, Fable 5 could move closer to being restored. If not, the shutdown may last longer than developers originally expected.

Why Was Claude Fable 5 Taken Offline?

Claude Fable 5 was reportedly taken offline after the US government raised national security concerns related to a possible method for bypassing the model’s safety safeguards.

The central claim is that Fable 5 may have been vulnerable to a jailbreak that allowed users to get around restrictions designed to prevent the model from assisting with certain cybersecurity tasks. Anthropic, however, appears to dispute the severity of the finding. The company’s position, based on public reporting, is that the demonstrated issue was narrow, non-universal, and related to vulnerabilities that other public AI models could also identify.

That distinction matters.

A broad jailbreak would imply that Claude Fable 5’s safety system could be reliably bypassed in a dangerous way. A narrow exploit, on the other hand, might suggest a more limited prompt-level or deployment-level issue that could be patched without fundamentally changing the model.

This is why the Washington meetings matter so much. The question may not simply be “does a jailbreak exist?” The better question is:

Can Anthropic prove that the reported Fable 5 jailbreak does not create a unique or unacceptable risk?

Why Are Anthropic Officials Going to Washington?

According to reports, senior Anthropic technical staff are expected to meet with government officials in Washington to work through the issue. That suggests the situation has moved beyond a simple support outage or internal model rollback.

These meetings are likely about three things:

1. Technical validation — proving what the reported jailbreak can and cannot do.
2. Remediation — showing whether Anthropic has patched or mitigated the issue.
3. Confidence-building — convincing officials that Fable 5 can be safely restored.

That last point may be the most important.

In a normal software incident, a company patches the bug, runs tests, deploys the fix, and restores service. But frontier AI model safety is not normal software reliability. If a government order or export-control concern is involved, then a fix may need to satisfy not just Anthropic’s engineers, but external officials who may be less interested in narrow technical definitions and more interested in worst-case misuse.

That means Anthropic’s task is not only to patch Fable 5. It has to prove the patch is enough.

Is This Really a Jailbreak?

This is where the story becomes complicated.

The word “jailbreak” is being used heavily, but not everyone seems to agree that the reported issue should be described that way.

In AI safety, a jailbreak usually means a prompt or technique that bypasses a model’s safety rules and causes it to produce outputs it should normally refuse. But not every controversial output is necessarily a full jailbreak. Sometimes the issue is a narrow prompt pattern. Sometimes it is a guardrail weakness. Sometimes it is a disagreement over whether the output should have been blocked at all.

That appears to be the dispute around Claude Fable 5.

Anthropic’s apparent argument is that the reported issue does not reveal a major new capability and does not make Fable 5 uniquely dangerous compared with other frontier models. Critics and officials, meanwhile, appear concerned that even a narrow bypass could be unacceptable if the model is powerful enough and the domain is sensitive enough.

That creates a difficult standard for Anthropic.

If the government expects Fable 5 to be impossible to jailbreak, that may be unrealistic. No frontier model is perfectly jailbreak-proof. But if the government expects Anthropic to demonstrate that Fable 5’s safeguards are robust enough for public release, that is a more practical goal.

The entire Washington discussion may come down to where that line is drawn.

Why Did Amazon’s Role Raise So Many Questions?

One of the more controversial parts of the story is Amazon’s reported role in raising concerns with senior officials.

Amazon has a close commercial relationship with Anthropic, which makes the reported escalation unusual to many observers. If Amazon researchers or executives had concerns about Fable 5, some developers naturally wonder why the issue was not handled directly and quietly with Anthropic first.

There may be several possible explanations.

Amazon may have viewed the issue as significant enough to raise through government channels. Government officials may have requested Amazon’s views on AI security risks. Or the reported concerns may have emerged within a broader national security discussion rather than a simple vendor-to-vendor bug report.

But from the outside, the optics are messy.

If a major Anthropic partner flags a risk that contributes to Fable 5 being taken offline, it raises obvious questions about trust, process, and escalation. Developers relying on frontier AI models want to know whether a model can disappear overnight because of a disputed safety report.

That is now one of the bigger concerns around the Fable 5 shutdown.

Could Claude Fable 5 Be Patched Today?

The honest answer is: possibly, but a same-day full return is far from guaranteed.

If the issue is a narrow prompt-level bypass, Anthropic may be able to apply mitigations quickly. Those could include system-level changes, policy-layer adjustments, monitoring updates, refusal tuning, or deployment-side safeguards. In that scenario, a technical patch could happen quickly.

But restoring Fable 5 is not just a technical question.

If the model was taken offline because of a government directive, then Anthropic may need external approval or at least enough government confidence before access is restored. That adds process, review, and political risk to what would otherwise be an engineering incident.

A same-day patch is realistic if:

• the reported jailbreak is narrow;
• Anthropic already has a mitigation ready;
• the Washington meetings are primarily about demonstrating the fix;
• officials accept Anthropic’s explanation;
• no wider review is required.

A same-day relaunch becomes less likely if:

• officials believe the issue reflects deeper model behaviour;
• the government wants stronger proof of jailbreak resistance;
• Anthropic disputes the premise rather than offering a clear fix;
• the export-control issue requires legal or administrative reversal;
• the concern expands beyond Fable 5 into Mythos 5 or future frontier models.

So the best read is this:

A same-day technical patch may be possible. A same-day full public relaunch is less certain.

What Would Anthropic Need to Prove?

For Fable 5 to come back quickly, Anthropic likely needs to prove several things at once.

First, it needs to show what the reported jailbreak actually does. If the issue only allows a narrow class of defensive vulnerability analysis, that is very different from a general-purpose bypass that unlocks dangerous cyber capabilities.

Second, Anthropic needs to show whether Fable 5 is uniquely risky. If other public models can produce similar outputs without a jailbreak, then the argument for keeping Fable 5 offline becomes weaker.

Third, Anthropic needs to show that any mitigation works reliably. That means testing against the original prompt, variants of the prompt, adjacent attack paths, and attempts to generalise the bypass.

Fourth, it needs to show that Fable 5 can be monitored after restoration. A model this powerful may not simply be patched once and forgotten. It may need ongoing red-team monitoring, abuse detection, logging, staged access, and stricter rollout controls.

Finally, Anthropic needs to restore trust with officials. That may be harder than the technical patch itself.

The Bigger Problem: Can Frontier AI Models Be Reliably Available?

The Claude Fable 5 shutdown exposes a bigger issue for developers and businesses.

Many teams are now building workflows around specific frontier models. They are not just asking general chat questions. They are using models for coding, debugging, research, document analysis, security review, and production workflows.

When a model like Fable 5 disappears suddenly, it creates real operational risk.

Developers have to ask:

• Can we rely on one frontier model for critical work?
• Should AI coding workflows always have fallback models?
• What happens when a model is restricted for policy reasons rather than technical downtime?
• Could other frontier models face similar sudden access limits?
• Are local or open models becoming more attractive simply because they cannot be remotely revoked?

This is why the Fable 5 shutdown has become bigger than Anthropic. It touches the future of cloud-hosted AI itself.

If access to the most capable models can be removed overnight because of a disputed jailbreak concern, businesses may become more cautious about building deeply around any single provider.

Why Developers Are Watching the Patch Timeline Closely

For developers, the biggest issue is not only whether Fable 5 had a jailbreak. It is whether Anthropic can resolve the situation quickly and transparently.

If Fable 5 returns quickly, this may be remembered as a short-lived safety incident. It would still raise questions, but the practical impact would be limited.

If the shutdown drags on, the narrative changes.

A longer outage would suggest that the issue is either more serious than Anthropic believes, harder to fix than expected, or trapped in a slow government review process. Any of those outcomes would be worrying for developers who depend on Claude’s most advanced models.

The Washington meetings are therefore a key signal.

If those meetings are about Anthropic demonstrating a fix, then a short outage is possible. If they are about negotiating broader safety expectations for frontier AI, then Fable 5 may not return as quickly as users hope.

What Are the Chances Fable 5 Comes Back Today?

Based on the available reporting, the realistic view is:

A same-day patch is possible. A same-day full restoration is uncertain.

If this is genuinely a narrow jailbreak, Anthropic may already have the technical ability to mitigate it. The bigger challenge is whether the people in Washington accept that mitigation as sufficient.

My rough read:

• Quick technical mitigation: plausible.
• Same-day full relaunch: possible, but not the most likely outcome.
• Short multi-day outage: probably more realistic.
• Longer regulatory dispute: possible if the issue becomes about process, trust, or future model-release standards rather than one specific jailbreak.

The key thing to watch is whether Anthropic or government officials describe the issue as remediated. If the language shifts from “shutdown” and “national security concern” to “mitigation,” “validation,” or “restoration of access,” that would be a strong sign that Fable 5 is moving closer to coming back.

Why This Incident Matters for Anthropic

Anthropic has built its brand around AI safety. That makes this incident especially awkward.

If Anthropic says the jailbreak concern is narrow and overblown, it has to explain that without sounding dismissive of safety risks. If officials say the model is dangerous enough to restrict, Anthropic has to show that its safeguards and release process are strong enough.

That is a difficult balance.

The company needs developers to believe Fable 5 is powerful and useful. It needs governments to believe Fable 5 is controlled and safe. It needs enterprise users to believe access will not vanish unpredictably. And it needs the broader AI community to believe its safety claims are technically grounded rather than political theatre.

That is a lot to solve in one Washington meeting.

What Happens Next?

There are a few possible outcomes.

1. Fable 5 Returns Quickly

Anthropic demonstrates a mitigation, officials accept it, and the model comes back with updated safeguards. This would be the cleanest outcome for developers.

2. Fable 5 Returns With Restrictions

The model comes back, but with stricter access, heavier monitoring, regional limits, or reduced capabilities in sensitive domains. This may be more likely if officials remain concerned but do not want a prolonged shutdown.

3. Fable 5 Stays Offline for Further Review

If the government wants more evidence, or if Anthropic and officials disagree on the severity of the jailbreak, the model could remain offline while testing continues.

4. The Incident Becomes a Precedent

The biggest long-term outcome is that Fable 5 becomes the first major example of a frontier AI model being pulled back after release because of government concern over jailbreakability. If that happens, every major model launch after this may face greater scrutiny.

Final Take

The Claude Fable 5 shutdown is not just another AI outage. It is a test case for how frontier AI models will be governed when powerful capabilities, safety safeguards, corporate partnerships, and national security concerns collide.

Anthropic’s Washington meetings matter because they may decide whether this remains a short technical incident or becomes a much bigger precedent.

If the reported jailbreak is narrow, Fable 5 could be patched quickly. But if officials want stronger proof that the model cannot be misused, the return timeline becomes harder to predict.

For developers, the practical lesson is already clear:

Do not assume access to any single frontier model is permanent.

Claude Fable 5 may come back soon. It may even come back today if Anthropic can satisfy officials quickly. But the incident has already changed the conversation around model availability, AI safety, and whether cloud-hosted frontier models can be trusted as stable infrastructure.

FAQ

Why is Claude Fable 5 offline?

Claude Fable 5 appears to be offline after reported government concerns around a possible jailbreak or safety bypass. Anthropic has disputed the severity of the issue and appears to view it as narrow rather than a broad model-level failure.

Is Claude Fable 5 permanently shut down?

There is no clear indication that Fable 5 is permanently shut down. The current question is whether Anthropic can resolve the reported safety concern and restore access.

Could Anthropic patch Fable 5 today?

A same-day technical patch may be possible if the issue is narrow. However, a same-day full relaunch depends on whether officials accept the mitigation and whether the restriction can be lifted quickly.

What are Anthropic’s Washington meetings about?

The meetings are reportedly about resolving the concerns around Fable 5 and Mythos 5. They likely involve technical validation, mitigation plans, and discussion around whether the models can safely return.

Was the Fable 5 issue definitely a jailbreak?

That is disputed. Some reports describe the issue as a jailbreak, while others suggest the research may have been defensive prompting or a narrow safeguard issue rather than a full jailbreak.

Why does this matter for developers?

Many developers rely on specific Claude models for coding and technical workflows. If a model can be taken offline suddenly, it creates operational risk and makes fallback models more important.

What should developers use while Fable 5 is offline?

Developers may need to switch temporarily to other Claude models, GPT-5.5, Gemini, local models, or whatever fallback is available in their workflow. The best option depends on whether they need coding, reasoning, security review, or general writing.

Will this affect future Claude model launches?

It could. If Fable 5 becomes a precedent, future frontier AI model launches may face more scrutiny around jailbreak resistance, cybersecurity safeguards, and government review before wide release.

rm -rf node_modules

npm cache clean --force

if you are using nvm to manage node version, ensure you have the right one selected for your build

source $NVM_DIR/nvm.sh && nvm use 14

npm install

You can now run your usual commands and all should work as expected. Example below.

npm run watch

npm run prod

Navigating different Node.js versions can be a challenge, especially when managing various projects. Enter the Node Version Manager (NVM), the go-to solution for seamless Node.js version management on a MacBook Pro. This guide walks you through the steps to effortlessly switch between Node.js versions using NVM.

Checking if NVM is Installed:

Begin by determining whether NVM is already set up on your device. Simply input the command below in your terminal:

command -v nvm

Should NVM be installed, the command will return nvm. If not, consider installing NVM first.

Installing a Specific Version of Node.js:

To install a desired Node.js version, use the nvm install command:

nvm install 14.21.0

NVM will promptly retrieve and install your specified version.

Switching Between Node.js Versions:

To alter the Node.js version for the current session:

nvm use 14.21.0

Your terminal will then adopt the chosen Node.js version.

Setting a Default Node.js Version System-Wide:

For a preferred Node.js version across all sessions:

nvm alias default 14.21.0

This ensures every new terminal session, irrespective of directory or project, defaults to using Node.js version 14.21.0.

Specifying a Node.js Version for a Particular Project:

For a project-specific Node.js version:

Navigate to your project directory.
Create a .nvmrc file:

echo "14.21.0" > .nvmrc

In the project directory, input:

nvm use

This confines the Node.js version to the one outlined in the .nvmrc file for that specific project directory. Remember to run nvm use each time you access the project directory or initiate a fresh terminal session there.

Embrace the convenience of NVM and enhance your development workflow. Juggle between Node.js versions with ease, ensuring optimal compatibility across your projects for a smoother development journey.

Today, I’d like to dive deep into a common issue that some of us might face when installing 3rd party packages using Composer on a MacBook Pro, especially when using MAMP. The issue manifests as the error:

sh: composer: command not found

The Background:

This error cropped up while attempting to install a package using the command:

php artisan breeze:install

Composer was being executed as a sub-service within this installation. So even if Composer was globally available, this specific process couldn’t recognize it.

Identify the Composer Execution Location:

Before fixing the problem, we first need to identify where Composer is being executed from. For this, the type command is a great tool:

type composer

This command will return the path to the executable.

Modify the PATH Environment Variable:

Your terminal checks the PATH environment variable to know where to look for executables. If the directory containing the Composer executable isn’t part of the PATH, the terminal won’t know where to find it. To ensure the terminal knows where Composer is, you can modify the PATH:

export PATH="/Applications/MAMP/bin/php/:$PATH"

By adding this line, you’re essentially telling your terminal to also look in /Applications/MAMP/bin/php/.

Conclusion:

Environment variables, specifically PATH, play a crucial role in how your terminal functions and locates executables. It’s essential to ensure the right directories are included in your PATH, especially when working with tools like Composer in a MAMP environment on a MacBook Pro.
If you ever encounter the “command not found” error in the future, remember to check your PATH and make sure the terminal knows where to look. Happy coding!

Did You Find This Helpful?

I hope this guide assisted you in resolving your Composer issue on MacBook Pro with MAMP. If you found this information beneficial, I’d love to hear your feedback. Feel free to share your thoughts and any additional tips you might have. Also, if you’re interested in more tech insights, coding tips, or just want to connect, follow me on Instagram at @kplcode. Let’s keep the coding conversation going!

Installing Node Version Manager (NVM) on macOS using Homebrew is a streamlined process that ensures you have more control over your Node.js environments. Below is a step-by-step guide on how to get NVM up and running on your Mac using Homebrew.

Installing Homebrew:

Firstly, you need to ensure Homebrew is installed on your machine as it’s required for installing NVM. Execute the following command to install Homebrew:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Installing NVM:

Once Homebrew is installed, you can proceed to install NVM using the following command:

brew install nvm

Creating a Directory for NVM:

NVM requires a directory to store different versions of Node.js. Create a directory for NVM using the command below:

mkdir ~/.nvm

Updating Your Profile:

Now, update your profile to include the necessary environment variables and source the NVM script. You can add the following lines to your ~/.zshrc or ~/.bash_profile file:

export NVM_DIR="$HOME/.nvm"
[ -s "/usr/local/opt/nvm/nvm.sh" ] && . "/usr/local/opt/nvm/nvm.sh" # This loads nvm
[ -s "/usr/local/opt/nvm/etc/bash_completion.d/nvm" ] && . "/usr/local/opt/nvm/etc/bash_completion.d/nvm" # This loads nvm bash_completion

Verifying the Installation:

After saving and exiting your profile, verify the NVM installation by executing the command below:

command -v nvm

Leveraging NVM for Project Versatility:

Installing NVM on your macOS not only streamlines the management of various Node.js versions but also significantly boosts your project’s versatility. With NVM, you can designate specific Node.js versions to individual projects, creating a tailored environment for each. This is a game-changer, especially when different projects rely on different versions of Node.js due to dependency requirements or compatibility concerns.

Furthermore, NVM provides a risk-free avenue to test newer versions of Node.js against your projects before making a system-wide update. This can be crucial in identifying potential issues or deprecated features that could impact your project, ensuring a smooth transition when you decide to update the Node.js version on your system.

By nurturing a controlled, project-centric environment, NVM aids in maintaining a robust developmental workflow, reducing the likelihood of version-related issues, and promoting code consistency across your projects. The ability to test, adapt, and manage Node.js versions effortlessly is why NVM is an indispensable tool in a developer’s toolkit.

Harness the power of NVM and elevate your development workflow to a more flexible and reliable state, paving the way for seamless project interactions and continuous integration amidst the ever-evolving landscape of Node.js.

const mediaSource = new MediaSource();
  video.src = URL.createObjectURL(mediaSource);
  mediaSource.addEventListener('sourceopen', sourceOpen, { once: true });

  function sourceOpen() {
    URL.revokeObjectURL(video.src);
    const sourceBuffer = mediaSource.addSourceBuffer('video/webm; codecs="vp09.00.10.08"');

    // Fetch beginning of the video by setting the Range HTTP request header.
    fetch('file.webm', { headers: { range: 'bytes=0-567139' } })
    .then(response => response.arrayBuffer())
    .then(data => {
      sourceBuffer.appendBuffer(data);
      sourceBuffer.addEventListener('updateend', updateEnd, { once: true });
    });
  }

The full article and source code can be found here

You may also be interested in learning how to implement push notifications onto a website. Read more and view source code

You can put you Laravel directory where ever you want, and it will work as expected, with one caveat – public path. By adding the following line to the top of your /public/.htaccess file, it will ensure your routing resolves as it should.

RewriteBase /laravel-folder

Two senior engineer las at Microsoft put together over 40 python videos, consisting of 2-3 per video, and uploaded the series to You Tube.

You can read the Microsoft blog post, and get links to the You Tube series Microsoft – learn Python

Sub URLPictureInsert() Dim Pshp As Shape Dim xRg As Range Dim xCol As Long On Error Resume Next Application.ScreenUpdating = False Set rng = ActiveSheet.Range("A2:A5") For Each cell In rng filenam = cell ActiveSheet.Pictures.Insert(filenam).Select Set Pshp = Selection.ShapeRange.Item(1) If Pshp Is Nothing Then GoTo lab xCol = cell.Column + 1 Set xRg = Cells(cell.Row, xCol) With Pshp .LockAspectRatio = msoFalse .Top = xRg.Top + (xRg.Height - .Height) / 2 .Left = xRg.Left + (xRg.Width - .Width) / 2 End With lab: Set Pshp = Nothing Range("A2").Select Next Application.ScreenUpdating = True End Sub

HTML

<img class="lazy" src="placeholder-image.jpg" data-src="image-to-lazy-load-1x.jpg" data-srcset="image-to-lazy-load-2x.jpg 2x, image-to-lazy-load-1x.jpg 1x" alt="I'm an image!">

JavaScript

document.addEventListener("DOMContentLoaded", function() {
  var lazyImages = [].slice.call(document.querySelectorAll("img.lazy"));

  if ("IntersectionObserver" in window) {
    let lazyImageObserver = new IntersectionObserver(function(entries, observer) {
      entries.forEach(function(entry) {
        if (entry.isIntersecting) {
          let lazyImage = entry.target;
          lazyImage.src = lazyImage.dataset.src;
          lazyImage.srcset = lazyImage.dataset.srcset;
          lazyImage.classList.remove("lazy");
          lazyImageObserver.unobserve(lazyImage);
        }
      });
    });

    lazyImages.forEach(function(lazyImage) {
      lazyImageObserver.observe(lazyImage);
    });
  } else {
    // Possibly fall back to a more compatible method here
  }
});

Demo below in codepen

See the Pen
Lazy Load Images by Kevin Lynch (@kevin-lynch)
on CodePen.

Original source: https://developers.google.com/web/fundamentals/performance/lazy-loading-guidance/images-and-video

sudo a2dismod php5.6 sudo a2enmod php7.2 sudo service apache2 restart

sudo update-alternatives --set php /usr/bin/php7.2 sudo update-alternatives --set phar /usr/bin/phar7.2 sudo update-alternatives --set phar.phar /usr/bin/phar.phar7.2 sudo update-alternatives --set phpize /usr/bin/phpize7.2 sudo update-alternatives --set php-config /usr/bin/php-config7.2

cd /foo/bar/laravelProject

You can then run any artisan commands

php artisan –version

NOTE: You must change to the working directory as stated above. You cannot simply do something like:

/foo/bar/laravelProject php artisan –version

=IFERROR(IF(VLOOKUP(A2,$B:$B,1,FALSE)=A2,"EXISTS"),"DOESNT-EXIST")

Type in the following to see the current PHP version:

php -v

Should output something like:

PHP 5.3.3 (cli) (built: Jul 9 2015 17:39:00)
Copyright (c) 1997-2010 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2010 Zend Technologies

Great, now we can move on!

2. Install the Remi and EPEL RPM repositories

If you haven’t already done so, install the Remi and EPEL repositories

wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-6.noarch.rpm && rpm -Uvh epel-release-latest-6.noarch.rpm

wget http://rpms.famillecollet.com/enterprise/remi-release-6.rpm && rpm -Uvh remi-release-6*.rpm

Enable the REMI repository globally:

nano /etc/yum.repos.d/remi.repo

Under the section that looks like [remi] make the following changes:

[remi]
name=Remi’s RPM repository for Enterprise Linux 6 – $basearch
#baseurl=http://rpms.remirepo.net/enterprise/6/remi/$basearch/
mirrorlist=http://rpms.remirepo.net/enterprise/6/remi/mirror
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-remi

Also, under the section that looks like [remi-php55] make the following changes:

[remi-php56]
name=Remi’s PHP 5.6 RPM repository for Enterprise Linux 6 – $basearch
#baseurl=http://rpms.remirepo.net/enterprise/6/php56/$basearch/
mirrorlist=http://rpms.remirepo.net/enterprise/6/php56/mirror
# WARNING: If you enable this repository, you must also enable “remi”
enabled=1
gpgcheck=1
gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-remi

Type CTRL-O to save and CTRL-X to close the editor

3. Upgrade PHP 5.3 to PHP 5.6

Now we can upgrade PHP. Simply type in the following command:

yum -y upgrade php*

Once the update has completed, let’s verify that you have PHP 5.6 installed:

php -v

Should see output similar to the following:

PHP 5.6.14 (cli) (built: Sep 30 2015 14:07:43)
Copyright (c) 1997-2015 The PHP Group
Zend Engine v2.6.0, Copyright (c) 1998-2015 Zend Technologies

Open the interactive example

[source]

Open the interactive example

[source]

With WordPress, installing plugins, updates and themes can be complex when trying to accomplish this via SFTP as opposed to FTP (which is supported within the WordPress core)

There is a plugin available to accomplish with minimal effort.

Step 1

Download This SFTP plugin Official wordpress plugin page

Step 2

Unzip the folder and you will find a the child folder named ssh-sftp-updater-support. Using an FTP client like FileZilla copy this child folder (including it’s contents) into /wp-content/plugins/

Step 3

Login to your wordpress dashboard and activate the SSH SFTP Updater Support plugin

Step 4

Open your wp-config file and paste in the following code, changing the credentials to what your SFTP login settings are

define( 'FTP_USER', 'user1' );
define( 'FTP_PASS', 'passWord123' );
define( 'FTP_HOST', '111.22.33.44:22' );
define( 'FS_METHOD', 'ssh2' );

Now you should be able to install themes, update wordpress and install plugins without any issues!

Putting your existing work on GitHub can let you share and collaborate in lots of great ways

Article source Github help

1. Create a new repository on GitHub. To avoid errors, do not initialize the new repository with README, license, or gitignore files. You can add these files after your project has been pushed to GitHub.

2. Open Git Bash.

3. Change the current working directory to your local project.

4. Initialize the local directory as a Git repository.

   git init
   

5. Add the files in your new local repository. This stages them for the first commit.

   git add .
   # Adds the files in the local repository and stages them for commit. To unstage a file, use 'git reset HEAD YOUR-FILE'.
   

6. Commit the files that you’ve staged in your local repository.

   git commit -m "First commit"
   # Commits the tracked changes and prepares them to be pushed to a remote repository. To remove this commit and modify the file, use 'git reset --soft HEAD~1' and commit and add the file again.
   

7. At the top of your GitHub repository’s Quick Setup page, click to copy the remote repository URL.

8. In the Command prompt, add the URL for the remote repository where your local repository will be pushed.

   git remote add origin remote repository URL
   # Sets the new remote
   git remote -v
   # Verifies the new remote URL
   

9. Push the changes in your local repository to GitHub.

   git push origin master
   # Pushes the changes in your local repository up to the remote repository you specified as the origin
   

This article covers creating a Federated table using Create Server. This is a required method when you want to create a Federated table and require password connection on the host database.

If you are creating a number of FEDERATED tables on the same server, or if you want to simplify the process of creating FEDERATED tables, you can use the CREATE SERVERstatement to define the server connection parameters, just as you would with the CONNECTION string.

The format of the CREATE SERVER statement is:

CREATE SERVER
server_name
FOREIGN DATA WRAPPER wrapper_name
OPTIONS (option [, option] ...)

The server_name is used in the connection string when creating a new FEDERATED table.

For example, to create a server connection identical to the CONNECTION string:

CONNECTION='mysql://fed_user@remote_host:9306/federated/test_table';

You would use the following statement:

CREATE SERVER fedlink
FOREIGN DATA WRAPPER mysql
OPTIONS (USER 'fed_user', HOST 'remote_host', PORT 9306, DATABASE 'federated');

To create a FEDERATED table that uses this connection, you still use the CONNECTION keyword, but specify the name you used in the CREATE SERVER statement.

CREATE TABLE test_table (
    id     INT(20) NOT NULL AUTO_INCREMENT,
    name   VARCHAR(32) NOT NULL DEFAULT '',
    other  INT(20) NOT NULL DEFAULT '0',
    PRIMARY KEY  (id),
    INDEX name (name),
    INDEX other_key (other)
)
ENGINE=FEDERATED
DEFAULT CHARSET=latin1
CONNECTION='fedlink/test_table';

The connection name in this example contains the name of the connection (fedlink) and the name of the table (test_table) to link to, separated by a slash. If you specify only the connection name without a table name, the table name of the local table is used instead.

For more information on CREATE SERVER, see Section 13.1.17, “CREATE SERVER Syntax”.

The CREATE SERVER statement accepts the same arguments as the CONNECTION string. The CREATE SERVER statement updates the rows in the mysql.servers table. See the following table for information on the correspondence between parameters in a connection string, options in the CREATE SERVER statement, and the columns in themysql.servers table. For reference, the format of the CONNECTION string is as follows:

scheme://user_name[:password]@host_name[:port_num]/db_name/tbl_name

Sometimes you may have a PHP script that takes a while to run. To keep the user informed on the progress of the script, and to reassure the user that something is actually happening, it would be advisable do display a progress bar.

This can be achieved in a number of ways. One way is via ajax and the other way is via SSE (server side events). In this article we will be covering the ajax version. This is my preferred method as it is the methoad that is most supported by browsers. IE does not support currently SSE. If you are interested in learning more about SSE please read PHP Long script progress bar using SSE

JavaScript:

$( document ).ready(function() {
    var jsonResponse = '', lastResponseLen = false;

    $("form").submit(function( e ) {
        $('.ajax-res').slideDown();
        $.ajax({
            url: $(this).attr('action'),
            xhrFields: {
                onprogress: function(e) {
                    var thisResponse, response = e.currentTarget.response;
                    if(lastResponseLen === false) {
                        thisResponse = response;
                        lastResponseLen = response.length;
                    } else {
                        thisResponse = response.substring(lastResponseLen);
                        lastResponseLen = response.length;
                    }

                    jsonResponse = JSON.parse(thisResponse);

                    $('.ajax-res p').text('Processed '+jsonResponse.count+' of '+jsonResponse.total);
                    $(".progress-bar").css('width', jsonResponse.progress+'%').text(jsonResponse.progress+'%');
                }
            },
            success: function(text) {
                console.log('done!');
                $('.ajax-res p').text('Process completed successfully');
                $(".progress-bar").css({
                    width:'100%',
                    backgroundColor: 'green'
                });
            }
        });
        e.preventDefault();
    });
});

Long Running PHP Script:

    $total = 25;
    $i = 0;
    echo json_encode(array('progress' => 0, 'count' => $i, 'total' => $total));
    flush();
    ob_flush();

    while ($i < $total) {
        $i++;
        echo json_encode(array('progress' => (($i/$total)*100), 'count' => $i, 'total' => $total));
        flush();
        ob_flush();
        sleep(1);
    }

View Demo

Download Code

View On Github

Thanks for reading!

Introduction

This article is based on an article written on htmly5rocks.

I wouldn’t be surprised if you’ve stumbled on this article wondering, “What the heck are Server-Sent Events (SSEs)?” Many people have never heard of them, and rightfully so. Over the years, the specification has seen significant changes, and the API has taken somewhat of a backseat to newer, sexier communication protocols such as the WebSocket API. The idea behind SSEs may be familiar: a web app “subscribes” to a stream of updates generated by a server and, whenever a new event occurs, a notification is sent to the client. But to really understand Server-Sent Events, we need to understand the limitations of its AJAX predecessors, which includes:

Polling is a traditional technique used by the vast majority of AJAX applications. The basic idea is that the application repeatedly polls a server for data. If you’re familiar with the HTTP protocol, you know that fetching data revolves around a request/response format. The client makes a request and waits for the server to respond with data. If none is available, an empty response is returned. So what’s the big deal with polling? Extra polling creates greater HTTP overhead.

Long polling (Hanging GET / COMET) is a slight variation on polling. In long polling, if the server does not have data available, the server holds the request open until new data is made available. Hence, this technique is often referred to as a “Hanging GET”. When information becomes available, the server responds, closes the connection, and the process is repeated. The effect is that the server is constantly responding with new data as it becomes available. The shortcoming is that the implementation of such a procedure typically involves hacks such as appending script tags to an ‘infinite’ iframe. We can do better than hacks!

Server-Sent Events on the other hand, have been designed from the ground up to be efficient. When communicating using SSEs, a server can push data to your app whenever it wants, without the need to make an initial request. In other words, updates can be streamed from server to client as they happen. SSEs open a single unidirectional channel between server and client.

The main difference between Server-Sent Events and long-polling is that SSEs are handled directly by the browser and the user simply has to listen for messages.

Server-Sent Events vs. WebSockets

Why would you choose Server-Sent Events over WebSockets? Good question.

One reason SSEs have been kept in the shadow is because later APIs like WebSockets provide a richer protocol to perform bi-directional, full-duplex communication. Having a two-way channel is more attractive for things like games, messaging apps, and for cases where you need near real-time updates in both directions. However, in some scenarios data doesn’t need to be sent from the client. You simply need updates from some server action. A few examples would be friends’ status updates, stock tickers, news feeds, or other automated data push mechanisms (e.g. updating a client-side Web SQL Database or IndexedDB object store). If you’ll need to send data to a server, XMLHttpRequest is always a friend.

SSEs are sent over traditional HTTP. That means they do not require a special protocol or server implementation to get working. WebSockets on the other hand, require full-duplex connections and new Web Socket servers to handle the protocol. In addition, Server-Sent Events have a variety of features that WebSockets lack by design such as automatic reconnection, event IDs, and the ability to send arbitrary events.

JavaScript API

To subscribe to an event stream, create an EventSource object and pass it the URL of your stream:

if (!!window.EventSource) {
  var source = new EventSource('stream.php');
} else {
  // Result to xhr polling 🙁
}

Note: If the URL passed to the EventSource constructor is an absolute URL, its origin (scheme, domain, port) must match that of the calling page.

Next, set up a handler for the message event. You can optionally listen for openand error:

source.addEventListener('message', function(e) {
  console.log(e.data);
}, false);

source.addEventListener('open', function(e) {
  // Connection was opened.
}, false);

source.addEventListener('error', function(e) {
  if (e.readyState == EventSource.CLOSED) {
    // Connection was closed.
  }
}, false);

When updates are pushed from the server, the onmessage handler fires and new data is be available in its e.data property. The magical part is that whenever the connection is closed, the browser will automatically reconnect to the source after ~3 seconds. Your server implementation can even have control over this reconnection timeout. See Controlling the reconnection-timeout in the next section.

That’s it. Your client is now ready to process events from stream.php.

Event Stream Format

Sending an event stream from the source is a matter of constructing a plaintext response, served with a text/event-stream Content-Type, that follows the SSEformat. In its basic form, the response should contain a “data:” line, followed by your message, followed by two “\n” characters to end the stream:

data: My message\n\n

Multiline Data

If your message is longer, you can break it up by using multiple “data:” lines. Two or more consecutive lines beginning with “data:” will be treated as a single piece of data, meaning only one message event will be fired. Each line should end in a single “\n” (except for the last, which should end with two). The result passed to your message handler is a single string concatenated by newline characters. For example:

data: first line\n
data: second line\n\n

will produce “first line\nsecond line” in e.data. One could then use e.data.split('\n').join('') to reconstruct the message sans “\n” characters.

Send JSON Data

Using multiple lines makes it easy to send JSON without breaking syntax:

data: {\n
data: "msg": "hello world",\n
data: "id": 12345\n
data: }\n\n

and possible client-side code to handle that stream:

source.addEventListener('message', function(e) {
  var data = JSON.parse(e.data);
  console.log(data.id, data.msg);
}, false);

Associating an ID with an Event

You can send a unique id with an stream event by including a line starting with “id:“:

id: 12345\n
data: GOOG\n
data: 556\n\n

Setting an ID lets the browser keep track of the last event fired so that if, the connection to the server is dropped, a special HTTP header (Last-Event-ID) is set with the new request. This lets the browser determine which event is appropriate to fire. The message event contains a e.lastEventId property.

Controlling the Reconnection-timeout

The browser attempts to reconnect to the source roughly 3 seconds after each connection is closed. You can change that timeout by including a line beginning with “retry:“, followed by the number of milliseconds to wait before trying to reconnect.

The following example attempts a reconnect after 10 seconds:

retry: 10000\n
data: hello world\n\n

Specifying an event name

A single event source can generate different types events by including an event name. If a line beginning with “event:” is present, followed by a unique name for the event, the event is associated with that name. On the client, an event listener can be setup to listen to that particular event.

For example, the following server output sends three types of events, a generic ‘message’ event, ‘userlogon’, and ‘update’ event:

data: {"msg": "First message"}\n\n
event: userlogon\n
data: {"username": "John123"}\n\n
event: update\n
data: {"username": "John123", "emotion": "happy"}\n\n

With event listeners setup on the client:

source.addEventListener('message', function(e) {
  var data = JSON.parse(e.data);
  console.log(data.msg);
}, false);

source.addEventListener('userlogon', function(e) {
  var data = JSON.parse(e.data);
  console.log('User login:' + data.username);
}, false);

source.addEventListener('update', function(e) {
  var data = JSON.parse(e.data);
  console.log(data.username + ' is now ' + data.emotion);
}, false);

Server Examples

A simple server implementation in PHP:

<?php
header('Content-Type: text/event-stream');
header('Cache-Control: no-cache'); // recommended to prevent caching of event data.

/**
 * Constructs the SSE data format and flushes that data to the client.
 *
 * @param string $id Timestamp/id of this connection.
 * @param string $msg Line of text that should be transmitted.
 */
function sendMsg($id, $msg) {
  echo "id: $id" . PHP_EOL;
  echo "data: $msg" . PHP_EOL;
  echo PHP_EOL;
  ob_flush();
  flush();
}

$serverTime = time();

sendMsg($serverTime, 'server time: ' . date("h:i:s", time()));

Download the code

Here’s a similiar implementation using Node JS:

var http = require('http');
var sys = require('sys');
var fs = require('fs');

http.createServer(function(req, res) {
  //debugHeaders(req);

  if (req.headers.accept && req.headers.accept == 'text/event-stream') {
    if (req.url == '/events') {
      sendSSE(req, res);
    } else {
      res.writeHead(404);
      res.end();
    }
  } else {
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.write(fs.readFileSync(__dirname + '/sse-node.html'));
    res.end();
  }
}).listen(8000);

function sendSSE(req, res) {
  res.writeHead(200, {
    'Content-Type': 'text/event-stream',
    'Cache-Control': 'no-cache',
    'Connection': 'keep-alive'
  });

  var id = (new Date()).toLocaleTimeString();

  // Sends a SSE every 5 seconds on a single connection.
  setInterval(function() {
    constructSSE(res, id, (new Date()).toLocaleTimeString());
  }, 5000);

  constructSSE(res, id, (new Date()).toLocaleTimeString());
}

function constructSSE(res, id, data) {
  res.write('id: ' + id + '\n');
  res.write("data: " + data + '\n\n');
}

function debugHeaders(req) {
  sys.puts('URL: ' + req.url);
  for (var key in req.headers) {
    sys.puts(key + ': ' + req.headers[key]);
  }
  sys.puts('\n\n');
}

Download the code

sse-node.html:

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8" />
</head>
<body>
  <script>
    var source = new EventSource('/events');
    source.onmessage = function(e) {
      document.body.innerHTML += e.data + '<br>';
    };
  </script>
</body>
</html>

Cancel an Event Stream

Normally, the browser auto-reconnects to the event source when the connection is closed, but that behavior can be canceled from either the client or server.

To cancel a stream from the client, simply call:

source.close();

To cancel a stream from the server, respond with a non “text/event-stream“Content-Type or return an HTTP status other than 200 OK (e.g. 404 Not Found).

Both methods will prevent the browser from re-establishing the connection.

A Word on Security

From the WHATWG’s section on Cross-document messaging security:

Authors should check the origin attribute to ensure that messages are only accepted from domains that they expect to receive messages from. Otherwise, bugs in the author’s message handling code could be exploited by hostile sites.

So, as an extra level of precaution, be sure to verify e.origin in your messagehandler matches your app’s origin:

source.addEventListener('message', function(e) {
  if (e.origin != 'http://example.com') {
    alert('Origin was not http://example.com');
    return;
  }
  ...
}, false);

Another good idea is to check the integrity of the data you receive:

Furthermore, even after checking the origin attribute, authors should also check that the data in question is of the expected format….

Demo

Here’s a demo app in PHP that keeps a clock up to date form the server.

References

• Server-Sent Events specification
• Cross-document messaging security

This tutorial will guide you step by step on how to setup your server so you can install new plugins and upgrade existing plugins using an SSH2 layer in PHP and WordPress.

What is WordPress?
WordPress started in 2003 with a single bit of code to enhance the typography of everyday writing and with fewer users than you can count on your fingers and toes. Since then it has grown to be the largest self-hosted blogging tool in the world, used on hundreds of thousands of sites and seen by tens of millions of people every day.

What is SSH[2]?
SSH (Secure Shell) is a protocol allowing a secure channel to be established between a web server and a client’s local machine. Many web hosting companies now offer SSH for greater security.

Tutorial Pre-requisites

Install ssh2 onto your server. Here’s a tutorial on how to do this Iinstall ssh2 Centos

Step 1: Generating the server-side RSA keys

ssh-keygen

Generating public/private rsa key pair.
Enter file in which to save the key (/home/user1/.ssh/id_rsa):
Created directory ‘/home/user1/.ssh’.
Enter passphrase (empty for no passphrase): (just hit enter, no need for a password)
Enter same passphrase again: (same thing, hit enter again)
Your identification has been saved in /home/user1/.ssh/id_rsa.
Your public key has been saved in /home/user1/.ssh/id_rsa.pub.
The key fingerprint is:
xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx user1@server1.example.com

The xx:xx:xx etc. will be replaced with your actual fingerprint.

Step 2: Creating an ‘authorized_keys’ file

cd .ssh
cp id_rsa.pub authorized_keys

Step 3: Setting the proper file permissions

cd ~/
chmod 755 .ssh
chmod 644 .ssh/*

Step 4: Choosing the ‘SSH’ option

In this tutorial, I opted not to use a password, so you do not need to enter a password.

Step 5: Click “Proceed”

The last step is to click the proceed button and it will install a new plugin or upgrade an existing plugin via the integrated SSH layer in WordPress. You should see results something like this…

Ensure Apache is the owner of the wordpress build

# Let Apache be owner (on centos this would be apache:apache)
sudo chown -R www-data:www-data /path/to/wordpress/build/

== Optional ==

If you want to automate the process a bit more, there are a few more things you can do to make it even easier.

If you open up your wp-config.php and add these lines, it will make the process smoother.

define('FTP_PUBKEY','/home/user1/.ssh/id_rsa.pub');
define('FTP_PRIKEY','/home/user1/.ssh/id_rsa');
define('FTP_USER','user1');
define('FTP_PASS','');
define('FTP_HOST','server1.example.com:22');

Now, when you click “upgrade” or “install” on a new plugin, it will bypass the first screen you saw above asking for the details. It will automatically go into the process and start the install/upgrade.

yum install gcc php-devel php-pear libssh2 libssh2-devel make

Install the extension, (hit enter for autodetect when it prompts you)

pecl install -f ssh2

Once the install is completed, you just have to tell PHP to load the extension when it boots.

echo extension=ssh2.so > /etc/php.d/ssh2.ini

Restart your webserver and test to see if the changes took effect.

service httpd restart

You can check it installed with the following command

php -m | grep ssh2

Reset Permissions

# Let Apache be owner (on centos this would be apache:apache)
sudo chown -R www-data:www-data /path/to/wordpress/build/

# Change location so you're at the root of the WordPress build
cd /path/to/wordpress/build/

# Change directory permissions rwxr-xr-x
sudo find . -type d -exec chmod 755 {} \;

# Change file permissions rw-r--r--
sudo find . -type f -exec chmod 644 {} \;

Tighten Security

After the setup you should tighten the access rights, according to Official Hardening WordPress all files except for wp-content should be writable by your user account only. wp-content must be writable by www-data too.

# Let your useraccount be owner
chown :  -R *

# Let apache be owner of wp-content (on centos this would be apache:apache)
chown www-data:www-data wp-content 

yum install php-pspell

Install en dictionary

yum install aspell-en

Restart apache

service httpd restart

View code usage example

sudo apt-get install libpspell-dev 
sudo apt-get install php8.0-pspell
sudo apt-get install aspell-en

Then restart your apache2 server with the following command

sudo service apache2 restart

PHP

$pspell = pspell_new('en','canadian','','utf-8',PSPELL_FAST);

function spellCheckWord($word) {
    global $pspell;
    $autocorrect = TRUE;

    // Take the string match from preg_replace_callback's array
    $word = $word[0];

    // Ignore ALL CAPS
    if (preg_match('/^[A-Z]*$/',$word)) return $word;

    // Return dictionary words
    if (pspell_check($pspell,$word))
        return $word;

    // Auto-correct with the first suggestion, color green
    if ($autocorrect && $suggestions = pspell_suggest($pspell,$word))
        return '<span style="color:#00FF00;">'.current($suggestions).'</span>';

    // No suggestions, color red
    return '<span style="color:#FF0000;">'.$word.'</span>';
}

function spellCheck($string) {
    return preg_replace_callback('/\b\w+\b/','spellCheckWord',$string);
}

echo spellCheck('PHP is a reflecktive proegramming langwage origenaly dezigned for prodewcing dinamic waieb pagges.');

First you have to go to the /tmp directory

cd /tmp

Download the composer.phar file

curl -sS https://getcomposer.org/installer | php

Move it to /usr/local/bin/

mv composer.phar /usr/local/bin/composer

Now you can to use the command composer globally.

sudo apt-get update

sudo apt-get install xvfb

sudo apt-get install wkhtmltopdf

(tested in ubuntu 14.04 x64)

Install PHP wrapper

Install php wrapper from github using composer

composer require mikehaertl/phpwkhtmltopdf

require __DIR__ . '/vendor/autoload.php';

use mikehaertl\wkhtmlto\Pdf;
// You can pass a filename, a HTML string, an URL or an options array to the constructor
$pdf = new Pdf(array(
    'no-outline',         // Make Chrome not complain
    'margin-top'    => 0,
    'margin-right'  => 0,
    'margin-bottom' => 0,
    'margin-left'   => 0,
    'viewport-size' => '1280x1024' // this is needed otherwise it will grab the mobile version of your website
));

// Add a page. To override above page defaults, you could add
// another $options array as second argument.
$pdf->addPage('http://www.example.com');

// On some systems you may have to set the path to the wkhtmltopdf executable
// $pdf->binary = 'C:\...';

if (!$pdf->saveAs('/path/to/page.pdf')) {
    echo $pdf->getError();
}

Step 1 – Install Node.js

Windows Users: Download and Install node.js onto your computer.

Mac Users: I recommend you do this via home-brew as opposed to downloading it from the official website. This will enable you to easily uninstall later, if you wish. Installing it using the official node.js website will result in multiple files being scattered in various places. This makes it a pain to uninstall as you will have to manually find and delete these files individually. Here’s a step by step guide on how to install node.js using home-brew

Step 2 – Install grunt cli

Install grunt cli globally by running the following command:

npm install –g grunt-cli

Step 3 – Install The Package Manager

Go into your website project root directory and install the package manager. Doing this will create a file called package.json file.

At a project level run the following command:

npm init

This will walk you through the project name, version etc etc.

Step 4 – Install grunt to your project root

Go into your website project root directory and install grunt. You need to install grunt at a project level in case the version of grunt changes when you are using grunt in a project. You will notice that the package.json file updated adding grunt as a dependency. You will also notice a node_modules folder. You will need to manually create a gruntfile.js, this is where you will control the modules etc

Install grunt by running in the following command within your website project root directory:

npm install grunt –-save-dev

Step 5 – Create the grunt file

Create a file called gruntfile.js at the website project root level. This will contain a node.js module which will control what grunt packages you web project uses and their settings.

Add the following code to the gruntfile.js file:

module.exports = function(grunt) {

 // configure task(s)
 grunt.iniConfig({

 });

 // load the plugins
 grunt.loadNpmTasks( );

 // Register task(s)
 grunt.registerTask('default', []);
 
};

Using Grunt

Now we need to add a task to grunt. We do this by carrying out the following steps:

• Load the plugin

  npm install <plugin-name> --save-dev
  

• Add congifuration to gruntfile.js

• Load plugin in gruntfile.js

• Register the task

We will use a plugin called uglify. This will shrink your javascript files down by compressing them and renaming variables to their smallest possible instance, amongst other things. It will also combine your javascript files into one single minified file.

Lets load the plugin:

npm install grunt-contrib-uglify --save-dev

Now lets configure the plugin within grunfile.js. Before doing this, ensure that you have your website folder structure in place where you can keep your non minfied javascript files seperate from you distirbution files.

In the example below we have our dev files in the src folder and our distribution files on the dist folder

/projectRoot/src/js/

/projectRoot/dist/js/

We can now add the uglify configuration to the grunfile.js file

module.exports = function(grunt) {

    // configure task(s)
    grunt.initConfig({
        pkg: grunt.file.readJSON('package.json'),
        uglify: {
            // method within plugin
            dist: {
                src: 'src/js/*.js',
                dist: 'dist/js/script.min.js'
            }
        }
    });

    // load the plugins
    grunt.loadNpmTasks('grunt-contrib-uglify');

    // Register task(s)
    grunt.registerTask('default', ['uglify:dist']);
};

The above uglify configuration will copy all js files within /src/js/ compress them and save the compressed version to /dist/js/script.min.js
In the example aboce we have set

uglify:dist

as the default task.

Update one table based on another table. This can be achieved when changes are made by using triggers.

In order to create a new trigger, you use the CREATE TRIGGER statement. The following illustrates the syntax of the CREATE TRIGGER statement:

CREATE TRIGGER trigger_name trigger_time trigger_event
ON table_name
FOR EACH ROW
BEGIN
...
END;

Let’s examine the syntax above in more detail.

• You put the trigger name after the CREATE TRIGGER statement. The trigger name should follow the naming convention [trigger time]_[table name]_[trigger event], for example before_employees_update.
• Trigger activation time can be BEFORE or AFTER. You must specify the activation time when you define a trigger. You use the BEFORE keyword if you want to process action prior to the change is made on the table and AFTER if you need to process action after the change is made.
• The trigger event can be INSERT, UPDATE or DELETE. This event causes the trigger to be invoked. A trigger only can be invoked by one event. To define a trigger that is invoked by multiple events, you have to define multiple triggers, one for each event.
• A trigger must be associated with a specific table. Without a table trigger would not exist therefore you have to specify the table name after the ON keyword.
• You place the SQL statements between BEGIN and END block. This is where you define the logic for the trigger.

MySQL trigger example

Let’s start creating a trigger in MySQL to log the changes of the employees table.

First, create a new table named employees_audit to keep the changes of the employee table. The following statement creates the employee_audit table.

CREATE TABLE employees_audit (
id INT AUTO_INCREMENT PRIMARY KEY,
employeeNumber INT NOT NULL,
lastname VARCHAR(50) NOT NULL,
changedat DATETIME DEFAULT NULL,
action VARCHAR(50) DEFAULT NULL
);

Next, create a BEFORE UPDATE trigger that is invoked before a change is made to the employees table.

DELIMITER $$
CREATE TRIGGER before_employee_update
BEFORE UPDATE ON employees
FOR EACH ROW
BEGIN
INSERT INTO employees_audit
SET action = 'update',
employeeNumber = OLD.employeeNumber,
lastname = OLD.lastname,
changedat = NOW();
END$$
DELIMITER ;

Inside the body of the trigger, we used the OLD keyword to access employeeNumber and lastnamecolumn of the row affected by the trigger.

Notice that in a trigger defined for INSERT, you can use NEW keyword only. You cannot use the OLD keyword. However, in the trigger defined for DELETE, there is no new row so you can use the OLDkeyword only. In the UPDATE trigger, OLD refers to the row before it is updated and NEW refers to the row after it is updated.

Then, to view all triggers in the current database, you use SHOW TRIGGERS statement as follows:

SHOW TRIGGERS;

In addition, if you look at the schema using MySQL Workbench under the employees > triggers, you will see the before_employee_update trigger

After that, update the employees table to check whether the trigger is invoked

UPDATE employees
SET
lastName = 'Phan'
WHERE
employeeNumber = 1056;

Finally, to check if the trigger was invoked by the UPDATE statement, you can query the employees_audit table using the following query

SELECT
*
FROM
employees_audit;

You will see the trigger was invoked as it has inserted a new row into the employees_audit table.

Let’s say you only wish to insert a new row into employees_audit when a particular column has changed value. In the example below a new row will only be inserted if the employeeNumber has changed.

DELIMITER $$
CREATE TRIGGER before_employee_update
    BEFORE UPDATE ON employees
    FOR EACH ROW
    BEGIN
        IF NEW.employeeNumber <> OLD.employeeNumber THEN
            INSERT INTO employees_audit
            SET action = 'update',
            employeeNumber = OLD.employeeNumber,
            lastname = OLD.lastname,
            changedat = NOW();
        END IF;
    END$$

In this tutorial, you have learned how to create a trigger in MySQL. We also showed you how to develop a trigger to audit the changes of the employees table.

A Full Example

 DELIMITER $$

CREATE TRIGGER table1_bi BEFORE INSERT ON table1 FOR EACH ROW
BEGIN
  INSERT INTO table2
	(ID, ColABc, Col2, Col3)
		VALUES
	(NEW.ID, NEW.ColABc, NEW.Col2, NEW.Col3);
END $$

CREATE TRIGGER table1_bu BEFORE UPDATE ON table1 FOR EACH ROW
BEGIN
  UPDATE table2
	SET
	ID = NEW.ID,
	ColABc = NEW.ColABc,
	Col2 = NEW.Col2,
	Col3 = NEW.Col3
   WHERE ID = OLD.ID;
END $$

CREATE TRIGGER table1_bd BEFORE DELETE ON table1 FOR EACH ROW
BEGIN
   DELETE FROM table2
   WHERE ID= OLD.ID;
END $$

DELIMITER ;