Cross-App Comments: Easier, Faster, and Better

Dave Jackson [00:00:00]:

Cross-app comments easier, faster and better.

Announcer: [00:00:04]:

This is the future of Podcasting, where we ponder what awaits the podcasters of today. From the school of podcasting, here's Dave Jackson.

and from the Audacity to podcast, here's Daniel J Lewis.

Dave Jackson [00:00:19]:

Daniel, I got to tell you, I had some fun with Chapters. We talked about this in the episode about Chapters. I'll have a link to that out in the episode description. But I made a mistake. That's always fun. And I had I know this is shocking for those of you that know me, I had a typo in the person's name in the Chapter file. And we said one of the benefits of the new kind of form of Chapters is I just went into the Chapter file, fixed the name. Now in this case, because I use Bunny, thanks to you, the CDN, I renamed it and deleted the original one and then updated my link in the episode because I didn't want to have to go through and clear the cache in that whole nine yards. I was like, you know what, I'll just give it a new name and update everything. And it was fixed in like you blinked and it was there. And I was like, wow, that was really cool. But I didn't have to download the episode and fix it and upload it and re export. So I now totally see one of the advantages of this new form of Chapters. And I know Chapters used to be your favorite feature, but that has now been replaced by a new one.

Daniel J. Lewis [00:01:25]:

Yeah, and I can't believe that when I listened back to that episode that we did, I was realizing, why didn't I mention this other thing that not only was a favorite feature, but now is my new favorite feature coming? And podcasting. 2.0 But I'll tell you, it's a feature that has been desired and talked about for more than a year, maybe since the beginning. And it's just gone nowhere. And I think that's because it's been too complicated. But I've had an idea. I had a light bulb moment. And I think we can move forward with this if developers are ready. So the feature that I'm now much more in love with is cross App comments.

Dave Jackson [00:02:14]:

There we go. Let's let the pigeons loose.

Daniel J. Lewis [00:02:17]:

Adam Curry, this is for you. That's it.

Dave Jackson [00:02:20]:

Well, it has been talked about a lot. And there were talks about using different things in Fountain and all these other everybody's like, well, what if we did this and what if we did this? And if you're not quite sure of an example of this, I think everybody likes to talk about YouTube. The fact that you can leave a comment on your phone and it's still kind of the same app, it's still YouTube. And that's the magic of it. It's like, hey, you know how you see those comments in YouTube and you can go to your phone, you can go to your iPad, you can go to your computer and all the apps follow you. Now picture that happening. But instead of everybody being in YouTube, you could be in Fountain and see the comments and then you'd go to Castomatic and then you'd go to Potverse and then you'd go to whoever and you're going to see these comments. And that's powerful. I mean, that's a great community builder. You say, oh, I just built it.

Daniel J. Lewis [00:03:11]:

So when we're talking about comments, yes, what I love about this and why part of this light bulb moment is this is very audience focused and everything I try to think about in the Podcasting 2.0 project, I try to run through this filter of how does this benefit the audience? Because that's whom we should be serving first with Podcasting 2.0, making the experience better in some way for the audience. Engagement between the podcaster and their audience is huge and allowing the audience to engage with each other. You said the magic word yourself, community. And that's when you turn individual listeners into a family, into a community, into super loyal listeners because they have relationships with each other. Like, tell me, what do you see happening every Saturday morning when you do ask the podcast coach live.

Dave Jackson [00:04:07]:

Yeah, we have a chat room that's going crazy. In many cases, they're having their own show. Like Jim and I are talking about topic A and somebody will say one thing, hey, has anybody ever seen the thing? And they just start having their own conversation, which is great fun. And to me, I think one of the magic parts of this community, cross app comments, is the fact that most really great ideas think about it. Cross app comments, you talked about it, we've been talking about this forever. Or and people are like, what if we did this? What if we did this? And what if did this? And then somebody gets a light bulb moment and that's where the great idea comes out and you're like, oh, but what if we did this? And that's, I think, one of the great things that come about because you're going to have everybody commenting on a topic or whatever it is, and then somebody's going to go, but what if we did this?

Daniel J. Lewis [00:04:55]:

Now we're talking. So it's not just reading the comments too. Although some apps could. This system is so dead simple, any app could read the cross app comments. Even if the app can't make a comment, it can still display them. So that means they can display on your website. And when we're talking about comments, we're saying comments on individual episodes. So they could display on your website, they could display in some embedded player, they could display in the mobile apps, they could display wherever. Because reading it would be so dead simple that if we use it in this way that I've been pushing for and now built something for today, and then people can if they're using an app that would support this, they can respond to someone else's comment too. So we're talking about comments beyond simply great episode. And these would be still public comments, but they wouldn't be boostagrams. So kind of like in Twitch or YouTube live shows, you can see people are chatting in the chat room and then someone does a super chat or something else by some other name where they've paid they've given a donation with that message. So that message appears much more prominent. That would be supported with this too. So then you can start to see a community build where they are responding to each other. They're also engaging with you on your content. And you might love this too. Some apps could very easily use this information to try to build dave, you're going to hate this Word charts. It could be Top Engaged podcast because it would be so easy to bring this information in.

Dave Jackson [00:06:35]:

And then we could hire people from the Philippines to leave comments. And I guess that is something we should ask about because Adam has the troll room. This is a great feature for community, but that also means the door is going to be cracked open for the idiot to come in and go, you guys suck. So how is that going to be controlled? Have we thought that far ahead?

Daniel J. Lewis [00:06:56]:

Yes. So here's what I've been saying, is that I've got a whole GitHub. I've got two things on GitHub. Don't let that scare you. You can just read some text in there that I made this whole list of. Here's what I think are the requirements. This was a year ago that I made this list to say, here's what I think cross app comments need to enable. Among those things would be the podcaster's. Full control over what appears. If someone is hosting the Christian Family Podcast for children, they don't want someone coming in and posting profanity and pornographic text as a comment and having no control over that. There also needs to be the control to be able to edit something. Maybe someone accidentally entered the wrong URL, spelled something incorrectly, got a fact wrong. They need to go back and correct that. That ability needs to be there. There needs to really be the ability for the podcaster to be able to move wherever they want to. We get that with our media files and basically our RSS feeds and our images and our websites and that kind of stuff, where we can just pick up and move it wherever we want to. And some of these systems, like when you use lipson to power your RSS feed and then you move to WordPress or move to Captivate or move to Transition or Transistor transistor with Worship or Sha in it, when you move to any of these companies, they're probably going to use that on their marketing. Now, if you move to any of these companies, between them. You are completely switching the publishing software that's creating your RSS feed, but it's still generating an RSS feed that looks almost the same, in some cases, exactly the same for all your past episodes, and the new episodes are slightly different. So this light bulb moment for me, after that post from a year ago, and even in that post I closed it and said, okay, I agree with going in this other direction that I think has more potential. Well, that other direction never went anywhere because it was complicated. It involves this thing called Activity Pub, and other people are saying, well what if we use Nostar for this and all of these things that to put it simply, are basically proprietary technologies that just to read the comments requires special software, just for the comments to exist on the Internet requires special software in those cases. So the light bulb moment for me because I had this very super brief moment one evening where I posted saying, what if we just make boostograms cross app comments because we already have Boostergrams in several apps, but each cross app comment cost only one sat, which is such a tiny amount of a penny. It's not even a full penny. And then that sat is paid for by whatever. I offered some things and then got some good feedback on that and withdrew my suggestion there in just a couple of hours. So that light bulb moment was realizing in podcasting, here are the different types of assets that we have that make your podcast. You've got your RSS feed, you've got your media files, you have images, and if you're doing Podcasting 2.0 stuff, you have transcripts and you have episode metadata which contains your chapters. Well, all five of those things are all totally portable. You can host your transcripts and your episode metadata on Bunny, on your own FTP server, on your website, whether it's WordPress or something else, it can be your podcast hosting provider host it. And if you switch hosting providers, you can take all of that with you. Your RSS feed, however you're generating your RSS feed, you can copy that code, save it to a file, upload that to Amazon S Three or Archive.org, and your podcast can live on forever without paying for podcast, media hosting or anything that's generating your feet. And I'm not saying to do this for an active podcast, but if you just want to archive it, you're like, this is done, I just don't want it to die from the internet. But there's really no reason to keep paying for stuff you can do that kind of thing. It can be a static file on a website, and then a static file is a file. It's not generated by database calls and APIs and all of this stuff. It's just a file that can live somewhere on the Internet. Some systems generate that dynamically, some systems don't. So I realized all of these things are totally portable. They can be hosted on a static server. Why not make cross app comments the same way so that you'd get total portability? You could host it anywhere, you could host it yourself, you could run software on your site or use a third party service that manages it for you. Your podcast hosting provider could manage it for you, but it's in a format that all you have to do is download it and move it to somewhere else if you need to. That's what we need in podcasting. And this method that I've come up with doesn't require special software for the commons to merely exist. That's the thing with Activity Pub, or as I understand it, is like with Mastodon, is based on Activity Pub. And that kind of thing is that you have to have the server running in order for that data to be accessible. Just kind of like your WordPress website. All the data is stored inside a database, and to have your website running, WordPress has to be there in order to interpret all that data from the database and then display it in the proper format and everything. But Podcast stuff shouldn't be that way. It needs to be portable, it needs to be decentralized, so you could move it wherever you want to. So my proposal for this is also super easy for developers to integrate. I think this is a big problem. Why? We've got all of these amazingly smart developers in Podcasting 2.0 and none of them, well, very few of them, I can't say none of them because some of them have implemented some things, but it's just not caught on because there are all of these complications around the system that we've been talking about previously. And I put out this proposal today and some actual code that shows the proof of concept. And already one of the developers said, put this in your feed. I will work on getting this in my app so we can have an app that actually tries it and we can test this out, see how it works. And that's because it's so simple. Now, please, I don't want this to be like Daniels telling everyone that he provided the solution to world peace and that I'm amazing or anything. I don't want this to be about me. It's just I'm really excited about this because I think this is a way, finally, that we can move this forward in a way that everyone will love.

Dave Jackson [00:13:50]:

Again, I have zero programming background, but if you think about it, an RSS feed has an item, which is your episode, and then it has a bunch of text about that item. And you could say, well, here is an item, but this item, instead of being an episode, it's still kind of an episode. So that way you could have comments per episode, which is what you're talking about. So you have that item to kind of tack it to something, to tie it to something and then it's just text and then it's just a matter of it will be text. We'll worry about making it bold and pretty later, but for now let's just get some communication going.

Daniel J. Lewis [00:14:28]:

And even that, like with RSS, which is a particular flavor of XML, you can create your own podcast RSS feed by hand, open it in a notepad app or something like that, copy and paste, change certain things. You can do that because it's open source and you can edit the information however you want. That's something that would be also possible with these cross app comments. So the way that this would work, and this is where it starts to get a little technical, so I'll share kind of some of the technical side, but also try and keep it a little layman level to make it make sense because I know not everyone who listens is a developer.

Dave Jackson [00:15:09]:

That's what I'm here for.

Daniel J. Lewis [00:15:11]:

The way that this works is you have two files. One of these could be a database, but the other one is definitely a file. You have a pending comments or a queue and then you have the published comments. The published comments are a file, always a file. I would suggest actually that they go in the same episode metadata file where the chapters are because then it's the same kind of thing where anytime an app would load the chapters, it would also load the cross app comments and as frequently as it updates the chapters, it can update the cross app comments. A reason for this, instead of having one file that holds all the comments for your entire podcast is what if you get one episode that has 1000 comments on it and then one episode that has one comment on it. Well to load that episode with the one comment means all the other 1000 comments have to be downloaded. That's just wasting bandwidth. So separating the comments into separate files for each episode makes good sense. Just like we do for chapters and then putting them in the same file where the chapters go also makes sense because like I keep calling it, it's an episode metadata file, it's not a chapters file. Right now all it holds is chapters. But we can put much more into it without breaking it because of the way that it's formatted with what's called JSON code or some people say JSON.

Dave Jackson [00:16:47]:

I knew somewhere, I don't even get the joke, I just know every time they talk about Daniel J. Lewis somebody go like oh, did he want to do it in JSON? So I knew I was going to hear Jason JSON, whatever it is. I was like, I knew that was coming.

Daniel J. Lewis [00:17:00]:

Yeah, I'm not going to live that one down. But the big advantage here is developers love JSON because it is so easy to read and manipulate inside of an app. The way that apps now basically work with each other is through JSON. Originally it was, XML was the way that apps would communicate with each other and XML is the language behind RSS. RSS is just a particular flavor and a standard of XML code. But JSON is completely different format. It's still pretty easy to read if you stare at it long enough and if it's formatted or it's broken down and structured well, but it's super easy for developers to integrate. They don't have to have special interpreters because most of these apps just recognize JSON format natively. And so the comments would then be in the episode metadata file with the chapters all in JSON format. So these two buckets, your queue and your published. The published is a file that exists, it's the same place where your chapters are, so it is publicly accessible. There's nothing about it that requires authentication or authorization in order to access the chapters and the comments for that episode. It's just there. It can be downloaded, it can be accessed. It's best if it's on a CDN like Bunny or your podcast hosting provider or something like that, but it's right there nothing fancy required to download it. For the app developers, they can ingest that data extremely easy because it's in JSON format, so it's right there on the public. You could even manually edit that JSON file, copying and pasting the comments from your queue into that published file if you wanted to. But it would be really easy to make a system, and I made one in only a couple hours today. I'm not this super advanced programmer, I'm still learning programming languages, but I made one based on JavaScript and Node JS that can do this. It's a proof of concept. It's not complete, but it manages the system. So you have something, a listener service running that could be as simple as a plugin in WordPress. It could be some standalone software that you run on your website. It could be a third party service. Like I will be integrating this into the future version of my podcast reviews when version 2.0 comes out later this year. It could be something that your podcast hosting provider runs for you and it's very simple and so that would make development for it very fast. So there's this listener service and when someone is listening in a podcast app dave, pick a podcast app.

Dave Jackson [00:19:49]:

Let's go podverse.

Daniel J. Lewis [00:19:51]:

Okay, so someone is listening in podverse, they like something in your episode and they want to comment on it, not sending a boostogram, or maybe they do want to send a boostogram because the system can receive boostograms too, or at least the comment from those boostograms. So your listener is listening in podverse and they make a comment. That comment gets sent to a service, this service that's running on your website or wherever, and it receives that comment. And the first thing it does is it doesn't publish it. So you don't have to worry about bad stuff appearing next to your podcast. It goes into a moderation queue so that's that first bucket, it sits in there. Now you can set up certain rules where you could say anything from an already verified app can automatically publish to my feed. So if someone comments from podverse, then that would already be in the database of podverse is a verified app, that this is a legitimate podcast app. It has the permission to post into cross app comments so the podcaster could choose to let those comments come through from any verified app. So if podverse has a comment that comes through, it could automatically publish. And if XYZ app from you Becca, Becca Beckham comes through then it automatically does not publish, it stays in the queue. Or maybe it even gets an extra flag because it's completely unrecognized. Maybe it gets flagged as possible spam because something just doesn't look right here. And there would be a little security handshake that happens in the background so that people wouldn't be able to spoof one app or the other. So the comment comes in through podverse. You as the podcaster would have a simple interface where you could go in and see here are all of these comments. This interface could even send you an email notification when you receive a new comment and you can go through and approve them or delete them or maybe you need to edit them for some reason. You can do that same kind of thing on WordPress. You can edit people's comments on your website, which can be handy in case they use profanity, but the rest of their comment is great and you don't want profanity on your website so you can just edit out the profanity, replace it with some dashes or something, let their comment be there, anything like that. You would have that ability and then you hit approve. And what the approve would do is it removes it then from that pending bucket and moves it over into the published bucket for that episode. So then it's there in the file which is then available for any of the apps out there. So it's totally readable, it's totally portable. It's really easy to run and develop for this once you see a basic model of it working. In the couple of hours that I spent developing this, that was a couple of hours figuring out how I wanted it to work along the way. Now that I've done, I think most of the hard work on figuring it out and what it needs to account for and there will be many other things too that I haven't thought of and there are things that the community will bring up which will be great to get more conversation and testing on this. But I think most of that trail has been cut and so I really think that it might take a developer only 15 or 30 minutes to build this into their app to support podcasts. And it would take other developers like Captivate or Lipson or anybody, it would take them maybe a couple of hours of developer time to build it into their system to give you the moderation abilities as the podcaster. I think we can do this. And you can't tell I am really excited about this by the fact that I've been talking almost this whole episode about this. Because this is something the community wants. It might not be something they're asking for. It's like, was it Ford who said something like, if I asked people what they wanted, they would have asked for a faster horse, but instead he gave them a car. And you see Apple do this frequently too, where they give us stuff that people don't ask for, but later on we realize, oh man, yeah, this is not like the iPad. I remember ridiculing Apple when the iPad came out. Of course, the name. Now we're all just like, yeah, iPad, none of us even think twice about the name anymore. And MacBook. We were all like, Mac Break Mcmick or what is it from McDonald's? Now we just say it without thinking. And there are plenty of other examples of this, but this is something that I think when the community has it, they will enjoy. And this is one of the reasons why boostograms are so much fun, is it's engagement with the community. And what I love so much about it is that it's engagement right inside of the app. They don't have to go out somewhere else, they don't have to log in to anything else. And that's like what you have with Activity Pub is they have to have an account on that Activity Pub system. And there are different Activity Pub servers and the management of those servers and how they communicate with each other. It starts to get really complicated and look like spaghetti.

Dave Jackson [00:25:08]:

Basically, the more little hurdles you put between you and the comment, the more likely people go, never mind, forget about it or whatever. I have one question again from the non developer mind of Dave Jackson. So I've got Chapter information in a file and now I tack on a bunch of comments. Is that going to mess up an app that's already set up to read Chapters? Is it going to get that extra text and go, what's that, George?

Daniel J. Lewis [00:25:36]:

No. And this is why I keep telling people it's not a Chapters file, it's an episode metadata file.

Dave Jackson [00:25:42]:

There you go.

Daniel J. Lewis [00:25:43]:

Because the way, without getting into describing actually how JSON works, is that inside of the file there are sections to the file, there's a hierarchy to it, a structure. And when you open the episode metadata file, one of the first things you will see is there is a Chapters section. So it's not like you open it and all you see are Chapters. You see a Chapters section and inside of that are the chapters. So the same thing here with these cross app comments is there would be a comments section added below or above the order. Doesn't matter. Inside of JSON, that's another really nice thing about it. Wherever it goes in the file, it would appear in there. So it's still structured, but then it's the comments section. So it shouldn't mess up anything because any app that reads the chapters, since it's in JSON format, it's really easy for that app to just go in to say metadata, file chapters and then grab all the information. Well then all they need to do is same file. Instead of looking at the chapters section, look at the comments section and then grab those comments and display them. Nice.

Dave Jackson [00:26:54]:

It is the AC DC of Podcasting 2.0. Very simple, yet it rocks. So you got to love it. So you are very excited about this. It's fun to just you can't see this, obviously the listener, but Daniel is lit up like a Christmas tree right now when he's talking about this. So that's awesome.

Daniel J. Lewis [00:27:12]:

Yeah, because this is the kind of thing that really helps you build and most importantly, keep an audience when they get this engagement, not only with you, but with each other. I've had a podcast about a TV show before once podcast, where the show lost popularity after its second season. Like the most common comment I hear from people when they hear that I had a podcast about the TV show is they say things like, oh yeah, I watched the first season of that show. That's the most common thing I hear because most of the people dropped off after the second season. We continued for all seven seasons and many of our audience for our podcast was still there because of the community that they had, the engagement they had with each other. So this whole cross app comments thing isn't just them commenting on you. The comments can also be in response to other comments. So if someone posts a question, someone else can come in and answer that or they can add another tip or they can help you out, they can build on the top of the conversation. So you're getting a community here, you're engaging your audience, you're getting great information from them. Just like the same reason, and podcasters probably know this, the same reason why we want that engagement anywhere else, whether it's on your website, on Twitter and Facebook Groups, anything like that. But the beauty here is in what it's called cross app comments. It's across multiple apps. You can be listening from podverse and post a comment. I could be listening in curiocaster and post a response to your comment which still goes back to the same episode. It's open, it's versatile, it's really fast and easy. It's all of those things. It's portable, it gives the podcaster the full control that they need. And that I keep telling. Podcasters demand control of your content. You need control of your content and you need portability, even if you don't have total control. Because Dave, honest question here, can people get into their Lips and RSS feed and change anything they want to?

Dave Jackson [00:29:30]:

Not directly, because it's based on the.

Daniel J. Lewis [00:29:34]:

You'Re saying they don't have full control?

Dave Jackson [00:29:38]:

No, because it's dynamically generated. So you'd have to go back to whatever the episode was and change it there. You have control, but not directly to the actual file.

Daniel J. Lewis [00:29:48]:

And it's partially a trick question. So I'm not throwing Lips in under the bus here. Is that really, in all of these systems, you probably don't truly have full control, but you have portability that if I get frustrated with PowerPress, yes, I could go into the source code, try and figure it out and make it do what I want it to do. Sure, yeah, that's total control for a nerd, but you can't do that on Lipson. But I could take my PowerPress feed and if PowerPress couldn't do something I wanted it to do but Lipson did, I could decide, you know what, I'm going to take my feed, I'm going to migrate it over to Libson. So it's not total control, it's not absolute control over every tiny little detail of my feed, but it is full ownership and freedom, really, with it that you can take it wherever you want and you can change what you want. And that's the same thing here with cross app comments allowing you to move this between different things.

Dave Jackson [00:30:54]:

Well, and you might know this as the guy behind my podcast reviews, right? We all love our one star reviews. Well, guess what, now you have control over that person's. Like this shows, blah, blah, blah. Well, guess what? That's not going to get published.

Daniel J. Lewis [00:31:09]:

You could stop that since you brought up reviews too. This is a framework which could be used for reviews just as easily. So you could have cross app reviews. Now, there's an extra layer that would be necessary to that. I was thinking about this earlier today, is that you don't want people, the podcasters themselves, to be able to just copy and paste a bunch of fake reviews onto their own podcast, right? So I have some ideas of a way to solve that. So I'm keeping that in my mind as I develop this cross app comments idea and implementation so that can be future focused and versatile. But that's a separate thing. Still, though, this is laying the groundwork that could support even that too, which would be a lot of fun as well. So that in whatever app you're listening to, you could give your favorite podcast five stars, give it a rating and review, and then anyone in any other app would be able to see that too, without needing to access some advanced API with authentication and authorization tokens and all of that advanced stuff. It's a simple file on the Internet that anything could download and access.

Dave Jackson [00:32:24]:

Very cool. It'll be fun to watch. Now that you've like you said, you've developed this enough for proof of concept and now as you take it out to the community, that somebody's going to go, oh, that's really cool, but what if we did this and that and that and stick with the simplicity and get it up and going and it'll be fun to watch. So congrats on sitting down for a couple of hours and going, but what if we did this? And you go, it's alive, it's alive.

Daniel J. Lewis [00:32:51]:

And if you're thinking, well, what if we did this instead? Or you want to comment on some of this, we'll include a couple of links in the notes for this episode that will be very helpful for you. One will be and these are both going to be GitHub links, but please don't let that scare you. You can just read stuff if you want. The code is there if you want to see the code, but one will be the link to my repository where the source code is for my work in progress proof of concept, which might change significantly in the days between when we're recording this and when we publish it or when you're hearing this. So it could change significantly there, but at least you could follow it, see the model that I'm building there. So that's one place. The other link that we'll include will be another GitHub link to instead the Podcasting 2.0 discussion where I originally had that list of, I think 15 or 17 items that I think cross app comments need to do that I then closed after a couple of weeks or so, but I've reopened it. Just like Jesus Christ, it's been risen from the dead. And now I've posted in there. So that's probably where most of the conversation will happen about this and what is possible with this as we develop this. And so those are two places you can follow. We'll have those link in the notes so you can comment there if you want to suggest anything, if you just want to see what some of the thoughts are going into this. I also have a video that's very rough, very geeky, shows, API calls and such. But you can kind of see how quickly and how simply it works, where even though I'm showing code, you can see I press this button, this comment appears here in the queue. Then I press this button and the comment disappears from that queue. And it now appears in the published comments. It's that quick and easy so you can see that kind of magic happen if you want to. Those are in the notes for this episode.

Dave Jackson [00:34:38]:

Excellent, because I was hoping I could watch the API as soon as I heard this I'm like, is there a video of the API? I hope so.

Daniel J. Lewis [00:34:46]:

Put that on a T shirt.

Dave Jackson [00:34:48]:

Well, the other thing we need to do before we wrap things up is we want to thank we didn't have any boostograms, but we wanted to say thanks to Gene Bean and Mitch Downey. Mitch is the guy behind podverse and everybody who has been streaming SATS to the show, we do deeply appreciate that. Until next week, again, everything we have is going to be in the show description, all the links, check those out and we'll see you next week with another episode of the future of podcasting.

Daniel J. Lewis [00:35:17]:

Keep boosting and keep podcasting.