Tag: WordPress (Page 68 of 219)

Articles, tips, and resources for WordPress-based development.

Sharing Databases in Dropbox (For MAMP Pro)

February 14, 2017 / Tom

Sharing databases is something that’s convenient to do within your local development environment especially if you’re working with multiple machines.

If for whatever reason you’re looking to do this with a staging environment or production environment, then this is not the way to do it. There are strategies like database replication and the like that are meant for that, and that are far beyond the scope of this post.

Instead, this is primarily intended for systems that you have, likely on the same network, and that you swap between during the day.

WordPress Batch Processing with Locomotive

February 10, 2017 / Tom

WordPress batch processing doesn’t exactly sound like the most exciting aspect of programming (regardless of the platform, really). And working with large sets of data in WordPress usually comes down to one of two solutions:

using WP-CLI,
performing migrations with WP Migrate DB Pro.

Both of these solutions are great, and they do their job well; however, there are times when you’re working with large sets of data within the WordPress administration area that could be manipulated with a simple batch process.

This isn’t to say that using the command-line is bad, but sometimes toggling a few options to work with posts, comments, or other data types would be nice.

And that’s what Locomotive from Reaktiv Studios allow us to do.

WordPress Metadata Association: Relating Entities

February 9, 2017 / Tom / 0 Comments

At this point, we’ve covered how to create the entities within the plugin (which, as we’ve said, is just a fancy word for another concrete idea). Namely, we’ve got a user and a custom post type, or a book. And here’s where we start to take the two separate entities and combine and work with what we’ll call WordPress metadata association.

But before doing so, it’s important to understand the two types of metadata with which we’ll be working and the two ways (or three ways, depending on how you look at it) in how we can associate the metadata.

As with the rest of the posts in the series, this isn’t meant to be a deep-dive into understanding each of the tables or a deep-dive into each of API functions. Instead, we’re going to survey what’s available, put them to use, and leave finer details for future posts (or perhaps discussions in the comments).

WordPress Post Types: An Abstraction For Entities

February 8, 2017 / Tom / 0 Comments

When programmers talk about entities, they are usually talking about a concept or something that has an existence within a system. Sometimes it’s a class, sometimes it’s a library or dependency, or it may be something like WordPress post types.

If WordPress is to be thought of as an application foundation (versus a framework), it’s important to think about certain features in ways that can be treated as entities. In the example above, a post type is just that.

When custom post types were introduced, it gave us a way to introduce something other than pages and posts into the application. Now we can implement any concept – like an event – and treat it as its own entity within the system.

But when all is said and done, it’s all saved in the posts table. And that’s fine because software development is all about abstraction. As we implement WordPress post types, we’re implementing an abstraction on top of the idea of posts.

Programmatically Creating WordPress Users

February 7, 2017 / Tom / 0 Comments

This post is the second part in a series I’m working through that talks about WordPress Metadata Association, and the first part of this involves working through the process of programmatically creating WordPress users (but it’s been five years!).

I’ve talked about doing this before, but things change over time as we gain more experience, right? And in working through a series like this, I think it helps to have a set of requirements we can follow, at the very least, to simulate what it might be like to have this happen in a real project.

So in this particular post, we’re going to take a look at the following:

Receiving user information in a particular data format,
Identifying what information is required to create a user,
Creating the user,
Making sure our code is up to par with coding standards and readability.

It sounds like a lot, though I’ve no intentions of making this a long post. That said, if this is something you’re looking to learn how to think through or how to tackle, then here we go.