Author: Tom (Page 67 of 427)

An Example of Retrieving Namespaced Properties in PHP

November 1, 2018 / Tom

When you write enough code that communicates with third-party APIs, you’re more than likely going to find yourself communicating with an XML-based API.

And say what you will about it: Some like it, some don’t. But they exist, and they are thus going to be a necessary part of your development at some point.

If the API is well-designed, it will likely use namespaces for different types of requests and responses. And when you’re writing the client for said API, then you’re likely going to need to go about retrieving namespaced properties.

It’s easy to do it, but it’s not immediately obvious. So in this post, I’m going to walk through an example of how to do just that.

A Look at We’ve Got Your Back by Freemius

October 31, 2018 / Tom

As someone who continues to participate in the WordPress economy, specifically in developing custom solutions for others, and as someone with many friends and acquaintances who are also developers, I know that one of the hardest things that we can do (aside from naming things) is branding and marketing a product or business.

I’ve written about Freemius a few times in the past (with the most visited post being All About Freemius for WordPress).

We've Got Your Back by Freemius

As such, I’m a fan of keeping up with what they are doing. Recently, they released a We Got Your Back program that aims to provide a solution to the problem marketing, branding, and so on of products those of us in WordPress build and strive to provide in WordPress.

A Strategy for Initializing Plugin Settings

October 30, 2018 / Tom

Whenever you’re working on a plugin that offers a page for its settings, there are several ways that you can save and retrieve the information.

Initializing Plugin Settings

You can:

use the Settings API,
use a custom page and calls that are a hybrid of the two,
use some type of hybrid between a submenu page (or a menu page) and other functionality.

The more I’ve worked with WordPress, the less and less I care to use the Settings API and opt to go with a bit of a hybrid approach.

Depending on the requirements of the project, the implementation will vary; however, I try to use a relatively consistent way to create the functionality.

And though this post won’t go into the various ways that I create my pages, related classes, and so on, it will offer one way that you can go about initializing plugin settings when working on your project or a project for someone else.

When You Get Bored with WordPress, Part 2

October 25, 2018 / Tom

In Part 1, I wrote a bit about what happens when someone gets bored with WordPress development. Specifically, I raised points of interest in:

Is it the community?
Is it the social (perhaps read: political) aspects of it?
Is it the fatigue of learning something new?
Is it the notion that you’ve learned all there is to learn about it?
And more.

And though I think it’s completely reasonable and acceptable to say “I’m ready for something new,” I think doing so under the guise of “I’ve learned all there is to learn about WordPress” to be a bit of an overstatement.

It’s a big piece of software with a lot of APIs, tools, and libraries around it. To make the claim that you’ve learned everything, there is to know about WordPress may be a stretch. I’m not saying it can’t be done (because there are people who have been involved with the project since it’s initial fork), but it seems unlikely.

Regardless, I thought I’d spend a few more words talking about the areas in which I’ve been involved and why I moved away from them as well as why I moved into the areas I’m in now.

Debugging for WordPress Developers: Changing Values at Runtime

October 24, 2018 / Tom

So far, this series has provided a series of screencasts that have provided:

In today’s screencast, I’m going to turn my attention to actually changing values at runtime while debugging. This means that while you’re executing your WordPress theme, plugin, or other web application, you can review and even change the values while the program is running.

Changing Values at Runtime

This is useful not only for debugging but for testing various sections of code that allow us to trace how the code is performing, where it’s branching, and if it’s running exactly as we’d expect.