WordPress Widgets: Refactoring, Part 10 And now, we start adding sanitization and serialization functionality into the WordPress Widget Boilerplate.

As far as the WordPress Widget Boilerplate refactoring goes, we’re at a good place. A lot of work has been done such that introducing new classes, features, and functionality should be much easier.

And not only that: It should be easier to follow.

Thanks the work in the last post, we have a lot of work to build off of – namely, an basic administrative interface.

WordPress Widget: UI Improved

Finally, the last post said:

Over the next few articles, this is going to continue to evolve but, as you can see, we’re making sure that we have a single base class of functionality for talking with WordPress and a class specifically for rendering the administrative form.

And that’s where we’re going to pick up in this article. Specifically, we’re going to look at sanitizing and serializing the data as well as retrieving the data saved in the widget.

Continue readingWordPress Widgets: Refactoring, Part 10 And now, we start adding sanitization and serialization functionality into the WordPress Widget Boilerplate.

Lessons on Launching (Three of Them, for Now) A quick summary of three lessons on launching that I'm trying to keep in mind.

One of the biggest things I’ve learned since trying out this whole podcasting thing (the second episode should be out next week, for those waiting with bated breath 🙃) is that achieving whatever arbitrary level of perfection before releasing something is hard.

Practical WordPress Development Podcast

You’d like I’d know this after so long in working in this field, right?

But there are several lessons on launching that I am trying to keep in mind especially as I’m working to get a few other projects off the ground all the while working in my day job.

Continue readingLessons on Launching (Three of Them, for Now) A quick summary of three lessons on launching that I’m trying to keep in mind.

WordPress Widgets: Refactoring, Part 9 We want to make sure that we're staying consistent with maintaining a high level of cohesion with our classes.

Though the last post in this refactoring series wasn’t incredibly long, I do think it was a bit dense. That is, it required a fair amount of work to get the code in a place that we can more easily work with it.

But that’s just it: All the work we did should make it easier to move forward with the rest of the code we need to write.

And to make sure that we’re taking advantage of the work and the foundation we’ve laid thus far, we’re going to round out the series with a set of shorter, more focused articles that should take less time to read, implement, and understand what we’re doing with the code.

Continue readingWordPress Widgets: Refactoring, Part 9 We want to make sure that we’re staying consistent with maintaining a high level of cohesion with our classes.

WordPress Programming: Separating Concerns Why bother separating functionality into subscribers and into other classes?

When it comes to creating classes for WordPress plugins, I’ve been asked about why I bother separating functionality into subscribers and into other classes.

I think this is a good question because it helps to understand two things:

  1. the role of a subscriber as it relates to the WordPress architecture,
  2. the role of the other classes as it relates to what it is you’re building (and how this can help with other things like unit testing and so on).

So I thought why not respond in the form of a short post? It’ll document the why behind the what [and it will give me a place to update if things change in the future].

Continue readingWordPress Programming: Separating Concerns Why bother separating functionality into subscribers and into other classes?

WordPress Widgets: Refactoring, Part 8 We'll start breaking apart the various components that go into making up WordPress widgets starting with the administrative area.

When it comes to refactoring the WordPress Widget Boilerplate, we’ve done a lot of work to bring the code base up to more object-oriented standard. Further, we’ve introduced a variety of other tools that allow us to bring our code up to more modern standards

Now that we’ve spent time doing that, it’s time to jump back into the code and begin refactoring it in such a way that allows for the use of abstract classes and subscribers (that work as part of the event-driven design pattern).

At the end of the previous post, I wrote:

In the upcoming posts, we’re going to look at how we can implement subscribers for the public-facing side of the site (that is, where the widget content is displayed). And we’ll do the same for the administration area of the site.

So in this post, we’re going to do exactly that. Specifically, we’re going to start with working on a subscriber for the widget and then getting the base widget to display on the administrative side of the site first.

Continue readingWordPress Widgets: Refactoring, Part 8 We’ll start breaking apart the various components that go into making up WordPress widgets starting with the administrative area.