Exploring the Interactivity API in WordPress Part 2

Brian Coords: You are listening to ViewSource, conversations around WordPress and adjacent tech with hosts, Aurooba Ahmed and me, Brian Coords

[00:00:09] Introduction

Aurooba Ahmed: Another day of recording. How's it going, Brian?

Brian Coords: It's good. I feel like I've been recording all day. I don't know if it's like calls and everything.

Aurooba Ahmed: Yes, you have, you've had a very busy day. That's for sure.

Brian Coords: Yeah,

Aurooba Ahmed: So last episode, we dug into our latest project, which is back in WordPress land. And we're building this reading list block using the very exciting and very cool interactivity API. We looked a little bit at how it kind of works. You showed us off, you showed us the front end of it.

And we sort of kind of looked at the code, but not too much. So should we look at the code and really dig into it today?

Brian Coords: yeah, definitely. I want to start by showing a little documentation. I think it's a good sort of

Aurooba Ahmed: This is like a really full circle thing. Yeah, go ahead.

Brian Coords: Yeah, yeah, because I feel like block editor documentation is something we need. Maybe talk about once in a while,

Aurooba Ahmed: Just here and there, you know, just in passing.

[00:01:21] Packages vs Feature Plugins

Brian Coords: this package, this is so, I mean, the way it works is like, there's like Gutenberg as a repository. And then inside there's a bunch of packages and each package is its own thing. You can NPM install, but WordPress has it all bundled. And if you're using the WordPress build process, then you don't really, cause it kind of just pulls the core version in.

But there's this package for the WordPress interactivity API, where all of the code relating to it exists as like a standalone little package. I mean, a package is a good word for it. And

Aurooba Ahmed: it's a mono repo, right? That's what Gutenberg really is.

Brian Coords: is a massive monorepo. And it's, I don't know, we were kind of talking about interactivity API. Like it, for a lot of people, it felt like it came out of nowhere.

And that's because it was really fully baked maybe before it made it into core, which is not always what happens in Gutenberg. A lot of times there's iteration and iteration and iteration. And. You know, change happening, but this was very much like, we're mainly because it's like a separate thing. It's like front end.

It's like, this is just a front end thing that we're, you know, we're literally doing on the front end. It's a tight scope. Exactly.

Aurooba Ahmed: yeah. What did you call it? You called it like, you know, they took that feature plugin approach, which is, I mean, we all agree it's a great approach. It's just, you don't see it often enough in the, in the Gutenberg world, you know?

Brian Coords: Yeah. And I, I think like a good example of a feature plugin is like performance team. They're doing these great. And they're even like breaking them into smaller plugins so that people can do it. They're doing like, they're doing an amazing job of just make a little feature, do it as a plugin. If that works, it's good.

And it's like, you can do that in core WordPress because it's very extensible, but like in the block editor, like it would be very hard to do a feature plugin for say, like updating patterns, you know? Like. Because they would, I mean, I think it would be good for them because then they'd have to go in and actually make everything extensible and then follow their own, like they'd have to turn everything into an API and then follow their own API guidelines to build features in the way core WordPress works, you know, is that everything can be.

Layered in it would, it would honestly maybe be a healthier approach.

Aurooba Ahmed: I mean, I agree. Like, I know that everything with a block editor and all the variables involved in it require to some extent an iterative approach, right? And you will always have these unknowns that you don't know what to do about, but being more thoughtful, being a little slower. in a way that makes you faster, because slow is smooth, slow is fast, as the saying goes.

Yeah, I mean, that's why WordPress became what it did. And if we want the future of WordPress to also be sustainable and help us grow, then we need to do the thing that actually works, which is being more thoughtful, being more iterative in a different way than we have been recently.

Brian Coords: Yeah.

[00:04:24] Browsing the Documentation

Brian Coords: Building things for other people to build on top of, which means clear documentation, lots of APIs, lots of extensibility, those are just kind of. I think this, I haven't looked too much into extending this, but as far as documentation and it's sort of self contained like approach, this

Aurooba Ahmed: You

Brian Coords: guide is really well done for the interactivity API.

I will say, I think you have to read it. build some stuff, come back and read it again, and maybe like that third round of reading it. And like, at the first time I looked at this diagram, it really made no sense to me. But now that I've been playing with it and stuff, I come back to this and I'm like, Oh, yeah, like, I'm totally sort of understanding this, this, this.

Idea of where does context live? Where does state, what are, you know, directives doing? What are, you know, all these different pieces that play together, what's happening on the server, what's happening, client side, all this sort of stuff. So it's it's, it's just a really good example of somebody spending the time documenting the CO.

And the code itself too is, as we'll see, is really well documented.

Aurooba Ahmed: Yeah, I mean, I've gone through this reference a couple times now, and it really does build on itself. You know, you start with something a little bit more easy to understand, or and then you go deeper and you go deeper, which means that one, if you were to read this thing from start to bottom, which by the way, sometimes we should really do that with documentation.

The stuff you learn by doing that is absolutely amazing. A little shout out to Aaron Francis right there. But, then you can come back and look at the pieces that you actually want to look at and dive deeper into them as you're actually using it and that still helps and that still works too, which I think is what you're saying.

And I think that's awesome. It's awesome that this thing, this interactivity API allows us to do that because that's how, I don't know. I mean, we all learned WordPress by reading the amazing codecs back in the day, didn't we? Which was like that.

Brian Coords: yeah. Which had, you know, because it was so like functional, it was easy to just say like, what's a function that does this? And there it is. This one is, is pretty good because it does start with directives, which is I think where we'll start, which is the sort of HTML attributes that sort of set up the scaffold and stuff.

And then I think once you kind of get through the directives, then it digs into What you're going to do, like actually in JavaScript, when you want to like, get a little more complicated and build like a larger store to handle more interactivity. But like you, for a lot of use cases, you might not even get to this place.

Like you might actually live just in directives and you could, for a lot of different types of blocks and things like that, that'll actually end up being more than enough to just sprinkle a little interactivity into it.

Aurooba Ahmed: Which, again, serves to demonstrate how that, you know, the thought that was put into this documentation is great because they put the thing that's probably the most common, immediately actionable, right at the top, and then you get more and more complex, which is really how it should go. So I'm excited to dig into this and really, really look at how it's applying because we're using some of the more complex things here in this plugin, right?

Brian Coords: Yeah, I think so. Like as you get further down and we're going to have to get more complex, which I, I think we'll talk about at the end of this episode, cause I'm not entirely sure the best approach. And that's what I like the way that I deal with something that I don't know what to do is I talk it out and I try to explain what I'm trying to do or something, and I think that's what good documentation is, is like, I'm going to explain this feature to you as simple as I can, and I, And like that process informs how you keep like working on it.

So like, if you're stuck on a feature, right, start documenting it, start explaining it and teaching it, even if it's not fully done, because that's going to help you go like, oh yeah, conceptually, this makes no sense. Or, oh yeah, conceptually, I should be thinking of it this way. You know, it's,

Aurooba Ahmed: Yeah. Or what about this? Or, oh, I forgot about that.

Brian Coords: Yeah. And don't, don't just let AI generate your documentation. Sometimes you got to really like, not all sometimes, but like. These sorts of like big conceptual pieces, I think these like narratives are really helpful.

Aurooba Ahmed: I agree. Totally. All right. So

Brian Coords: you want to see a

Aurooba Ahmed: in?

Brian Coords: reminder of our blocks?

[00:08:24] Preview of our frontend block

Brian Coords: Just to be clear, we have an interactive block. It's a bookmark. You click on it and it bookmarks or unbookmarks an article. I'll just like zoom in. And then that affects this larger reading list here, which is just a list of post IDs of all the posts that you've bookmarked.

So if I remove them, you know, it goes empty. If I add them, it does that. And these are two separate blocks that are interacting with each other.

Aurooba Ahmed: Yeah, which is awesome. And it's happening and it's really fast. It's going into our local storage, you know, it's just a simple array that we're storing. So it's, it's a really localized and contained, but still very relevant pattern and example that you could use the Interactivity API for.

Brian Coords: Yeah. And a lot of people would load, I've done load view or Alpine or something like that. I think under the hood they use Preact if I understand correctly which is like a very, very lightweight sort of framework for it. It's like the end of the day, like we need frameworks. Frameworks are good.


Aurooba Ahmed: Yes, and we are already loading it, right? We covered that last time. We already have it right now if you're using the site editor, if you're using the nav block. So we're, you know, reducing a dependency and making more use of a dependency we already have to deal with.

Brian Coords: Yeah. And the query loop which is, is like kind of an underrated feature that for a generic kind of based theme, the query loop can do like automatic reloads with the interactivity API. So you can do like you can show like three latest posts and have a little like show the next three, the next three no page reloads.

Super cool. All right. You ready to look at the code?

[00:09:53] HTML Directives

Aurooba Ahmed: Yeah, let's do it.

Brian Coords: Okay. So we've jumped over to the code editor. We looked a little bit last time about how we scaffold this as a block. Using the create block plugin, it's actually two separate blocks. There's a nice WordPress scripts build process. It's a little tricky cause we're using these JavaScript modules and stuff.

Let's start with the markup, the HTML directives piece of it and look at how we're sort of setting that up. And then I think from there we'll go into like the kind of JavaScript side of it. Does that sound good?

Aurooba Ahmed: Yeah, sounds like blend.

Brian Coords: Okay. So what's really cool is the fact that it's using these HTML, like directives, like data WP interactive is basically what you put to sort of initialize the whole thing.

Like once you put that on a piece of HTML, everything inside of it sort of understands that, like, we're now part of the scope of this interactive, like things. So you could put it. Super high up in the Dom. If you're going to like connect to different things, you can do it local and then call a different store, which is what we're doing here.

So you can just pass data to be interactive, but I'm specifically passing it the name of a store that we're going to define somewhere else. So that I can have multiple blocks and they'll all say like, Hey, just so you know, we're all using the same store. We're all talking. And because it's HTML, you can actually use.

HTML tag processor and not even do like, we're doing this in PHP, but like you can throw this stuff on any block using tag processor, render block function, all that sort of stuff. So it's definitely

Aurooba Ahmed: it allows you, so it allows you to send pointed to a particular reference point. You could not initialize it with that. And then it would be its own localized bit, or you can have a store. That's somewhere else somewhere. That's a gold, more global reference, perhaps, and it can point to that instead.

Brian Coords: Yes. And so, So that's the global store. Like the way I think of it is like, there's a global store for just this level of interactivity. Maybe like WooCommerce has their store that's dealing with all their stuff. This is our store for this reading list plugin. And then in this particular block, so just so you can kind of see the block basically is the bookmark button.

And when you're bookmarked, it says bookmark. When you're not bookmarked, it says. Bookmark, you know what I mean? Like it, I need to do some accessibility stuff, because I kind of want just like one screen reader, like text or something. And maybe even bring in like the post title and stuff like, some, you know, there's some, some extra

Aurooba Ahmed: definitely lots of improvements we can make. Yeah, for sure.

Brian Coords: yeah.

But that idea of like, this is a single blog post. Is it bookmarked or is it not bookmarked? That's not about the global. It's about this particular piece of data. So that lives in what's called the context. And the context is really like this little bundle of data. It's a piece of the store and you can get it from the store, but it's but in this particular situation, all this cares about is whether this particular post is bookmarked or not.

And so we've defined that. In the context. And so you can basically build a PHP array of any variables that you want available in the context. For example, I want the post ID because I want to be able to use that later on. But then we just use this function. That's just going to basically like Jason encoded or whatever into an attribute.

And then it's just going to live. Those two values are going to live just inside this one block that could be used multiple times in the page and each have their own context. Do I feel like I'm explaining that correctly?

[00:13:12] Conventions for binding and events handlers

Aurooba Ahmed: Yeah, that sounds really good and really smart. So I'm looking at this data WP bind and then it's dash dash hidden. So you're binding it to an attribute. Is that attributes that you're, you know, that end up after that double dash?

Brian Coords: Yeah. So there's a specific, there's different types of interact, like these attributes, these directives. There's like the one we looked at interactive to declare it. This one makes one called context. There's this one called init that we'll come back to, which is like an init function that'll just run once when the page loads.

And then there's the WP on and the WP bind. And those, if you've done any of these other ones. It's basically like an on click handler or binding to an attribute. And there's a limited set, but there's, I think like class, you can bind classes, you can bind style tags, you can bind this hidden and then it

Aurooba Ahmed: All the general things you would probably have to want to do anyway, right? I mean, it seems pretty comprehensive. Basic, but comprehensive.

Brian Coords: I mean, this is like, this is a pattern you see in Vue and Alpine, it's very common to have this, they use like an at symbol or like a colon in between or whatever, but it's a, it's pretty common, I think there's even a prevent, you know, if you've probably seen those, like where it'll be like a form submit prevent or something like that, like,

Aurooba Ahmed: Right.

Brian Coords: It's pretty, this is a, this is like people are, I think people will feel like, why not just use a thing that already exists?

And it's like, well, they are using these conventions. They're just, it's WordPress, hyphens for everything.

Aurooba Ahmed: It's not like they came up with this list themselves. They looked at what is the most common types of lists like this that already exist in other frameworks and then they pulled that in, so there's lots of data and lots of experience that is being baked into how this gets created. For sure.

For sure. So Basically, you have two spans, one is bookmark, one is bookmark like, one is like, if it is bookmarked, one that isn't bookmarked, and it's being controlled by that hidden attribute, which in turn is being controlled by this bind, this interactivity API directive that consumes data from the context,

Brian Coords: so right now the context for all of them is that is bookmarked as false. But we have this init function here that's going to live inside of the store and that's going to run when the page loads. Because whether it's bookmarked or not is not something we know at the server level. It's, I mean, I guess, yeah, we'll just say.

Aurooba Ahmed: Later on, later on, that may not be true, but right now, we don't know.

Brian Coords: Yeah. I think if you, now, if you had a user that was logged in and this is something that only logged in members could do, like subscribers that are logged in, then yeah, you might pull that out of the database and you would do that here at the moment of render. And that would be super cool.

We're not, we're grabbing it out of local storage in their like unique session. So what's going to happen is this init function, which we're going to look at is going to run and it's going to go through and it's going to update the context for any, any blocks that actually are bookmarked.

Aurooba Ahmed: Okay, so this will only run the first time this hits the DOM.

Brian Coords: Yes. Cool.

Aurooba Ahmed: That makes a lot of sense. Follows a very convention, like a very normal WordPress convention. I love that I can just know the word and know exactly what the intention is there. Yeah.

[00:16:31] Callbacks and Actions

Brian Coords: And the last, I think kind of interesting thing here is like, we have callbacks. init, which will be an initialization callback that we can do. And then we have an on click handler for a button. So if they click on the bookmark button and it has actions. toggle. And so what we'll look at is you basically have the global state, which we'll talk about.

You have callbacks and you have actions and callbacks and actions are both just functions that we're going to write. Which you could actually write in line here is like inline JavaScript. If you wanted to we won't, but you could, but they're just JavaScript functions and callbacks just generally sort of happen when state changes or context changes or something's initialized.

And then actions are functions that we just more explicitly want to run, that we want to call and say, Hey, do this action. Do this, click handler, toggle this bookmark.

Aurooba Ahmed: That reminds me of server actions that we looked at in the, in the WP audit checklist project, right? Where you had these server actions that were connected to the form. So you, I mean, it's really just these functions or these really like behaviors that happen, but they've. You've pulled them out because of the fact that they are a very, very common behavior, common thing you want to do, you know, you submit a form, you might probably want to do an action here.

If you click on something, you probably want to do something there where otherwise you could technically call it all callbacks, but having it structured like this provides a, all of us a ubiquitous language to speak with when we're designing things with that. So I like that a lot.

Brian Coords: So that's our bookmark block. This is our reading list block, which was the one that just shows what articles are in your reading list. So in this, we have the same thing. We're calling WP data to be interactive and, you know, calling our same store. So our, we're using the same store that we had before.

We have an initialization function where we're actually calling back and you'll notice we don't have any context for this block, which like we said, if we wanted to pull it from the server and we had that situation, we would in this case, there's really nothing. There's no information it needs.

It's, it's going to get all the information once the page loads.

[00:18:37] State, Context and Loops

Aurooba Ahmed: Right. That, that makes a lot of sense because all of that information is only client side right now. There's not, there's nothing on the server side anyway. It's all default by false. And I'm seeing another bit of what is living in that store here, which is state. Right? I'm reading that right?

Brian Coords: So we have a template, and in this template what we're doing is we're doing a WP data WP each, which is a, basically like a for loop. It's a, it's a, you can pass an array to it and you can for loop it through, and I'll have to make sure I explain this correctly. This took me four to get right.

Aurooba Ahmed: Oh, no.

Brian Coords: State in my state, I'm going to have an array of bookmarks, which we'll look at state is available to everybody. Everyone has the state of all the bookmarks. Each bookmark has its own little context because they're each little individual articles. I'm taking that loop, that list, and I'm looping through it and I'm, for each item, I'm assigning it to this right here, which we're going to call bookmark.

Aurooba Ahmed: That makes sense.

Brian Coords: Then inside of my for loop, I have context dot whatever I put here, which is bookmark, which is the value. And in this case, it's just an array of numbers. But if it was an array of like objects, I could, you know, keep dotting down and do like

Aurooba Ahmed: Yeah. Use that dot

Brian Coords: ID, whatever. Yeah. But it's just an array of numbers at this point.

[00:20:04] Using Attributes and Hydration

Aurooba Ahmed: I think the reason it must have been really hard. I mean, even when I look at this, because when we were looking at the last render, right? When you look at the way we do WP bind hidden, like here on line 25, it's almost like an if statement, but it's an if statement inside the freaking HTML.

Like, like, think about like in Laravel, we have like the at symbol, so you'd actually have the templating language outside of the elements. But here you have your, almost like a templating thing, but it's happening inside the element. And that's, that's a little trippy, not gonna lie.

Brian Coords: Yeah. I mean, you could imagine that if you had a shopping cart, you would pull in all the items on load from the server. Cause the shopping carts stored in like a transient or something, right. And then you would loop through the cart items and there'd be a pretty complicated way to render all of that.


Aurooba Ahmed: right.

Brian Coords: templating. I mean, that's, that's essentially what we're trying to do here is we're trying to mess around with the visual. Hierarchy here, but you know, would I have liked it to say as bookmark or something like,

Aurooba Ahmed: Exactly. Exactly.

Brian Coords: a little

Aurooba Ahmed: Or even,

Brian Coords: I,

Aurooba Ahmed: even here, like on line 22, like you have data wp text. And this is inside an anchor link. And the anchor link itself on here is empty, but it will get filled on the client side because it's wp text. So whatever's in there, that context. bookmark is actually going to be inside the DOM, but here it's empty.

And that looks really weird.

Brian Coords: yes. And like I said, this will eventually be an array, probably with, with an ID title and a URL so that I could. Make this link go to the, like, it needs to go to the article. I didn't get there yet. But yeah, this, and this is maybe a little bit closer. Well, like, you know, you do that kind of stuff in react.

Well, you do it for a

Aurooba Ahmed: No.

Brian Coords: but like, you don't need to do it for just like strings.

Aurooba Ahmed: Yeah, because you would just put that string variable something right where that, where it will actually live. But here, you're not actually doing that. I mean, it's fine. It's just really funky.

Brian Coords: Yeah. What's, but what's nice about why we were talking about earlier, which is. I can go to any core block and I can add this on top of it because of the HTML tag processor, the tag processor. Does not add stuff in between tags. You can't stick stuff in between here in the tag processor. You can only add attributes.

And so

Aurooba Ahmed: Yes.

Brian Coords: it's, it kind of makes sense. So you could add this attribute to a block and then it would get rendered when it all hydrates and stuff. So.

Aurooba Ahmed: Yeah. I, I, I, I'm glad you used the word hydrate because that's exactly what I was thinking. Like, you know, this is like, Basically hydration, which so many people, including you, by the way, sometimes don't like about React, the whole concept of hydration, but that is kind of what we're doing here. We're taking, we're sending over like an assumed scaffolding of HTML, and then we're hydrating it and adding the actual data on the client side.

It's very SPA, very single page application vibes.

Brian Coords: And honestly, if Java, if JavaScript broke and none of this ran, what we would have is none of this would really show, right? Cause there's just empty. There's no squiggle line, you know, there's no squiggly brackets that would show up. If you ever, I don't know if it still was like this, but I remember when I would use view and you'd always see that flash of like squiggle line until the data like hydrated and it was very annoying.

So right now we would just see this list item, really, you know, we would just see that the one list item with the text, you know, so it would degrade kind of nicely,

Aurooba Ahmed: Yeah, which is, which is nice. I mean, like, like we've said before, it's a good scope. It's well thought out. You know, it's not, you would not call this, this API half baked. It may not be everything in the world that you may want it to be, but it is not half baked.

Brian Coords: you know, I would say if you have any complaint, it's a steep learning curve, but I think that's the only complaint that I've had so far.

Aurooba Ahmed: Yeah, the DX isn't there.

Brian Coords: But it's a complicated thing to do. So like, I, you know, when you think about it

[00:24:01] Wrapping up and Next Steps

Brian Coords: So those are all of our directives and we've kind of touched a little bit on like state context, callbacks, actions, all that stuff. Should we go look at the JavaScript file for this?

Aurooba Ahmed: honestly I think this is already a really solid episode and it's been so fun to dig as Like so deeply into it and I want to do the store that justice as well So I think it would be great to wrap this up Let's talk about what we'll be talking about in the next episode and then dig just as deeply into that next topic.

Brian Coords: Yeah, I agree. I mean, the directives are, I think in planning, like I should have thought like directives really are, I mean, they're, they're, they're a large piece of it, like what happens to the HTML is a huge piece. And then what happens at the JavaScript level is a huge piece that really needs its own kind of time to like bake in, soak into it.

So I

Aurooba Ahmed: It's very meaty, right? It may not be the potatoes, but I think it's part of the meat You

Brian Coords: Yeah, and what we talked about in 30 minutes took me like an hour or two to like, just unwind and get like, get my head around. I can see if you're using this all the time, it would be super powerful. But yeah,

Aurooba Ahmed: we covered so much stuff. I mean, it's like a templating language you can use it with the tag processor. It's, you know, it's working with the server. We're hydrating. I mean, look at all these concepts, which when I really think about it, all these concepts that you and I have been talking about this whole season, and it's all like coming full circle into the interactivity API project.

And I, I kind of, I'm here for it. Yeah.

Brian Coords: there's definitely that part of you that's like, I wouldn't have minded some like blade style templating. I wouldn't have minded, you know, some more like component

Aurooba Ahmed: JSX ing or something.

Brian Coords: Yeah, a little bit more component based or like people are, people are very opinion about HTML X, I think is like an alternative to this approach.


Aurooba Ahmed: But aren't you seeing like how interesting it is that you and I have been exploring these WordPress adjacent technologies and then the perspective it's giving us when we're literally diving back into WordPress? I mean, I think we proved the point of our season theme already just by doing that right now.

Brian Coords: I think if we had not taken that journey, I'd be in here complaining. Why isn't it like this? Why isn't it like that? Why not like that? But like, once you've lived in each world, you kind of see like, Oh, there's reasons for a lot of things. And I think a lot of the reason for where this is landing is based on backwards compatibility and the way the block editor renders content.

And that's, you know, Going to be a big piece of it. So it's going to have to be a, a unique WordPress way, but I think people will see once we get to the JavaScript side, which we'll look at next time, that's pretty standard JavaScript, honestly, like once you're there, once you've made it through the directives and you're just in like state context, callback, that stuff yeah, I'm not going to say it's easy.

It took a bit of a minute to get, cause it is a bit reacty, but overall it's like

Aurooba Ahmed: because the block editor is React. We live in a reactive world in WordPress now. So that makes

Brian Coords: Yeah. Okay. So next week we'll look at the store. We'll look at the actual JavaScript. We'll do all that stuff. And then at some point I need to make this like a good accessible user interface that

Aurooba Ahmed: We will get there. For sure.

Brian Coords: yeah, I don't even know if we're going to get to like server side updates, honestly.

Aurooba Ahmed: Let's see where we get. I mean, this is, this is WordPress. This is our home. It's okay if our series takes a little longer,

Brian Coords: It'll, it's going to take at least an episode to do anything with the database. That's for sure. Sure. Sure.

Aurooba Ahmed: a hundred percent. I believe it. But I also think that's, would be really interesting and I don't think I've seen that many people, but maybe one or two actually, not, it's not really a thing that's being attempted very much yet. You know?

Brian Coords: just not a use case that it seems to solve particularly, or like, it doesn't have an opinion on how you're going to send stuff back to the database. There's, I will say if people are interested, there's a Gutenberg discussion thread where people are just sharing how they're using it. There's like Seth Rubenstein's really good to follow.

There's like the WooCommerce dev team is really good to follow. These are people that are actually using it in real life. And so you can read that thread and see how people are doing it and stuff, but which I need to do to do some homework. But it'll, yeah, those are some great places to see. And I think this is really in the weeds, advanced developer stuff for WordPress that you might not need, but you know, if you're making a little accordion block, this would actually be perfect for you.

Aurooba Ahmed: I think that, honestly, I can talk about this and the whole concept behind it and how cool it is and just how much stuff that, you know, I think a lot of us wish for and feel in terms of the principles of development, the, you know, things that we really, really are passionate about, like simplicity and static things that can be dynamic, but aren't necessarily dynamic from the start with and the power you get from that and the flexibility you get from that.

So much of that comes together into this API that it just, it makes my heart happy, you know? So I'm excited. I'm excited for our next episode where we dive even more deeper into this.

Brian Coords: All right, well then I'll see you then.

Aurooba Ahmed: Sounds good.

Visit viewSource.Fm for the show notes and if you're enjoying the show, we would love a review on iTunes or a comment on YouTube.

Creators and Guests

Aurooba Ahmed
Aurooba Ahmed
(she/her) Developer building bespoke #WordPress solutions, tools, and blocks. My name is pronounced "oo-ROO-ba" — Default to kindness, folks.
Brian Coords
Brian Coords
WordPress developer and writer blah blah
Exploring the Interactivity API in WordPress Part 2
Broadcast by