For those newer to the world of WordPress, you might only be casually familiar with WordPress plugins and their use. You might have only installed them and used them before but have you wondered what it would take to make your own? In this new tutorial from Toptal.com Ratko Solaja gives you a "ultimate guide" to getting started down the road of custom WordPress plugin development.

Plugins are a vital part of WordPress websites that need specific functionalities. While the official WordPress repository has more than 45,000 plugins from you to choose from, many of these plugins miss the mark.

Just because a plugin is in the repository doesn’t mean it won’t hinder its performance or compromise its security. So what can you do? Well, you can build your own.

He starts with the planning stages of his example plugin (a real-world project helps when learning new things) - one that allows users to save content for later reading. He outlines the goals of the settings screen, how saving will work, messages to the user and what the "saved" screen will do. He recommends starting with a boilerplate plugin and working from there. He then goes through each step of the development process:

• Handle activation and deactivation
• Create a plugin settings page
• Create the plugin functionality
• Make the plugin modular
• Generate translation files

The end result is a complete plugin with both the required frontend and backend functionality to make the "save content" feature work. All code is provided and plenty of links to more information and other resources are sprinkled throughout the article.

The PHP Roundtable podcast, hosted by Sammy Powers, has posted their latest roundtable discussion talking about all things Zend. In this episode Sammy is joined by Adam Culp, Cal Evans (both from Zend) and Gary Hockin (of JetBrains).

There's a lot more going on at Zend other than Zend Framework. We chat about the Zend ecosystem, from Apigility to Zend Certification and what Zend's role is in PHP internals.

You can catch this latest episode in a few different ways either using the in-page audio or video player or you can watch the video directly over on YouTube. If you enjoy the episode, be sure to subscribe to their feed and follow them on Twitter for updates on when new shows will be recorded and released.

On the Laravel News site there's an interesting post about learning "just in time" so you can not only keep up with the latest knowledge but not have to worry about things you don't actually need to know.

Technology—including the web—moves insanely fast. It can be intimidating (often annoyingly so) to try to not only consume the content constantly served to us, but also retain it. After all, isn’t the point of sharing information to learn from it? This just-in-time knowledge can be an unfriendly reminder that, no matter how hard we try, we will have a difficult time keeping up with the newest trends and tech.

[...] Luckily in tech, most of us have to keep up to date on software and hardware to be successful at work. But what if we’re swimming in a project at work and don’t have time to look into the new technologies? What if it’s nearly impossible to bake new knowledge into our jobs?

The article talks about methods for "knowledge gathering" you can do in small bites during your day, making use of them to keep up with the latest trends and technology. It also talks about retention, how sleep and training play into it and the where researching topics more in-depth can help.

Matt Stauffer has posted the next article in his series of "What's New in Laravel 5.3" series with this article covering the use of Vue.js with Laravel and some of the bootstrapping that makes it easier.

In Laravel 5.3, it's easier than ever to write and use Vue components out of the box. This means 5.3 has a somewhat more opinionated default frontend stack than previous versions do. But never fear—it's easy to strip out the default components.

Let's explore 5.3's JavaScript stack together. Spin up a sample app using the Laravel installer (or, if you're like me, use Lambo) and open up the site in your favorite IDE.

He starts with the sample definitions of the package.json and Gulp files, including some dependencies including Vue.js itself and the Vue Resource packages. He then shows a sample app.js file to define the main part of the application and a matching bootstrap.js with a bit of, well, bootstrapping for the application. Finally he creates the example component, runs yarn/gulp and updates a Blade template to lay out the main application div and include the application Javascript file. Finally he shows what the resulting application should look like with screenshot included.

Popular posts from PHPDeveloper.org for the past week:

• Leonid Mamchenkov: Feature Flags in PHP

• SitePoint PHP Blog: What Are Polymorphic Relations and How Do We Use Them with Eloquent?
• Stovepipe Systems: Rethinking Form Development
• Freek Van der Herten: Symfony and Laravel will require PHP 7 soon
• Amine Matmati: Symfony: the Myth of the Bloated Framework
• Matt Stauffer: Update to queue workers in Laravel 5.3
• TutsPlus.com: Building Your Startup: Security Basics
• /Dev/Hell Podcast: Episode 85: Brand Dilution as a Source of Happiness
• PHPUgly Podcast: Episode 41 - The Boys
• Master Zend Framework: How To Use Forked Repositories In Composer
• Paul Jones: PECL Request Extension: Beta 1 Released!
• Toon Verwerft: Optimizing PHP performance by using fully-qualified function calls
• SitePoint PHP Blog: Social Logins with Oauth.io – Log in with Anything, Anywhere
• Robert Basic: Using Doctrine DBAL with Zend Expressive
• That Podcast: Episode 35: Stuff
• Joe Ferguson: Mocking Swift Mailer – 3 Steps to better code
• Michelangelo van Dam: Sessions in PHP 7.1 and Redis
• Voices of the ElePHPant: Interview with Paul Jones (#2)
• Matt Stauffer: Using Vue in Laravel 5.3, with the Vue bootstrap and sample component
• PHP Roundtable Podcast: 057: All things Zend
• Toptal.com: The Ultimate Guide to Building a WordPress Plugin
• Laravel News: Just-In-Time Knowledge: How to learn what you need to know and forget the rest

The SitePoint PHP blog has a tutorial posted from Meni Allaman showing you how to use the OAuth.io SDK for social logins, integrating multiple social network logins in one centralized place.

Users today often like the idea of logging into websites with a single click using one of their social accounts.

Given that, today we will look at OAuth.io, which is a multi-platform SDK for more than 120 social login providers like Facebook, Twitter, and Google+. Working with such an SDK is not a difficult task, but there are some prerequisites for using it.

The tutorial then breaks down the steps to follow for getting the service set up and getting the required package installed. Following this the author shows how to connect your account to the various services and provides the code you'll need to connect to the OAuth.io service. It finishes up with an example of a page you'd need to provide to your users to let them authorize the connection to the OAuth.io service with the service of their choosing.

Toon Verwerft has a post on his site with details about a micro-optimization you can use in your PHP application by using fully-qualified function calls, specifying the namespace even for root level PHP functions.

Today, a little conversation on Twitter escalated rather quickly. Apparently PHP runs function calls differently depending on namespaced or non namespaced context. When calling functions in a namespaced context, additional actions are triggered in PHP which result in slower execution. In this article, I'll explain what happens and how you can speed up your application.

The conversation started with [this tweet]. To understand the difference between global and namespaced function calls better, I'll explain what is going on under the hood.

He starts with this "under the hood" functionality, showing an example of a user-defined, root level function and the opcodes that result. He compares this to the opcodes generated when a namespaced function is called and the extra checking that goes into it (including checking both the namespace and the root levels). Another tweet implied that, because of this difference in checking, fully-qualified function calls would result in a performance increase. He set out to prove it as fact and used the phpbench tool to run four tests with various namespaced and non-namespaced examples. He includes the code he used for the testing and the results from a sample execution. There is, in fact, a slight performance gain from the fully-qualified version. He finishes up the post with some suggestions on using this knowledge including the root-level namespacing for built-in PHP functions.

Robert Basic has written up a quick post to his site sharing details on how you can use Doctrine's DBAL with Zend Expressive without having to use the entire Doctrine ORM. DBAL is Doctrine's abstraction layer that makes it easier to work with your database at a higher level than writing manual SQL statements.

The database abstraction and access layer — Doctrine DBAL — which I prefer over other abstraction layers like Zend DB. My good friend James, aka Asgrim, has written already how to integrate Zend Expressive and Doctrine ORM.

But what if want to use only the DBAL with Zend Expressive, and not the entire ORM? It’s pretty easy as all we need to do is write one short factory that will create the database connection using the connection parameters we provide to it.

He includes the code snippet you'll need to define a "ConnectionFactory" to set up the connection and the configuration needed to allow it to connect to the database. He then shows how to set up the DI container with the new container factory as a dependency and use it by pulling the "db" object out of the container.

If you're a user of the SwiftMailer package in your application, you may have hit on issues with your unit tests with mocking the library to isolate it from the actual email sending. Joe Ferguson is here to help with some advice in his latest post on mocking the library and how he used it to solve a problem in his own code.

A few days ago an issue came across my Jira queue that mentioned odd characters showing up in the subject line of our notification system. We use SwiftMailer library which is a fantastic library for sending mail.

[...] Something was taking our twig template that we use for our email subject and changing the encoding. This is normally done when you want to convert special characters so they’re not interpreted as code blocks. The example above is showing where an apostrophe is converted to “'”, the ASCII code equivalent.

He breaks the rest of the post into 3 steps (well, really 4 but there's a 2.5 in there) that he followed to mock the library out appropriately and be able to test the message sending without actually having to send. Code examples are included of both the code doing the sending and the test doing the mocking and verifying the subject lines on their emails (the original bug reported).

That Podcast, hosted by PHP community members Beau Simensen and Dave Marshall, has posted their latest episode - Episode #35: Stuff.

Beau and Dave talk about stuff, including a voicemail from @jwage, generating ideas and discussion on twitter, new services we've seen or are using, the difference in number of attendees between European and US conferences, bucket list type things, what we're watching and planning on watching on TV.

Other topics mentioned include an article covering the choice of Vue.js over React, the Postmark service and Westworld (TV series). You can listen to this latest episode either using the in-page audio player or by downloading the mp3 of the show. If you enjoy it, be sure to subscribe to their feed and follow them on Twitter to get updates when new shows are released.