Whiskey Web and Whatnot

A whiskey fueled fireside chat with your favorite web developers.


92: Hot Takes, Bun, and Zig with Jarred Sumner

Show Notes

Jarred Sumner, Founder and CEO of Oven, is bringing speed to the world of Javascript with his project, Bun. Bun is a next-generation Javascript runtime bundler, transpiler, and NPM package manager that promises lightning-fast speeds. It's already making waves in the industry. The company secured seven million dollars in funding to build hosting for Bun in August 2022.

One of the secrets to Bun's success is its use of the underrated programming language Zig. Jarred explains that Zig allowed him to be incredibly productive and save time with its memory allocator. Another essential feature of Bun is its pre-allocation of almost everything, avoiding the need for dynamically pushing arrays, which can significantly slow down the process. The new version of Bun also has a different runtime than other frameworks like Node and Deno, making it even faster.

In this episode, Jarred talks to Robbie and Chuck about his views on trending Twitter topics, how his company uses benchmarks to optimize Bun's performance, and what he believes has happened to the creativity of the web.

Key Takeaways

  • [00:30] - Introduction to Jarred Sumner.
  • [01:17] - A whiskey review: Peerless Small Batch Kentucky Straight Bourbon
  • [04:42] - Tech hot takes.
  • [11:15] - Jarred’s new bundler.
  • [15:36] - Jarred’s reason for using Zig.
  • [18:52] - Upcoming hosting product Jarred’s team is working on.
  • [23:09] - What happened to the creativity of the web?
  • [27:58] - Jarred’s draft tweets.
  • [30:12] - Jarred’s hobbies besides coding.
  • [38:51] - Other developers and projects Jarred finds interesting.


[16:06] - “Zig is really productive. I tried to use Rust, and I just had a lot of trouble being productive.” ~ Jarred Sumner

[17:55] - “For CPUs, the thing that’s slow usually is not actually the processing, it’s memory.” ~ Jarred Sumner

[22:52] - “I think that we can make the internet and Javascript applications faster, and we can make it easier to deploy, and we can make it better. It going to be a lot of work, but it's going to be really fun.” ~ Jarred Sumner


Connect with our hosts

Subscribe and stay in touch

Top-Tier, Full-Stack Software Consultants

This show is brought to you by Ship Shape. Ship Shape’s software consultants solve complex software and app development problems with top-tier coding expertise, superior service, and speed. In a sea of choices, our senior-level development crew rises above the rest by delivering the best solutions for fintech, cybersecurity, and other fast-growing industries. Check us out at shipshape.io.

--- Send in a voice message: https://podcasters.spotify.com/pod/show/whiskey-web-and-whatnot/message


Robbie Wagner: [00:09] What's going on, everybody? Welcome to another Whiskey Web and Whatnot with myself, RobbieTheWagner, my co-host, as always. Charles Williams Carpenter III. Oh, you're not going to say anything?

Chuck Carpenter: [00:23] No, I didn't do anything this time. No, not this time.

Robbie Wagner: [00:25] Okay.

Chuck Carpenter:[00:25] I know you're waiting for the interruption, which makes it way less fun for me.

Robbie Wagner: [00:29] Yes. Okay, so our guest today is Jarred Sumner. What's going on, Jarred?

Jarred Sumner: [00:34] Hey.

Robbie Wagner: [00:35] So, for the folks at home who have not heard of you, can you please give them a little description of who you are and what you do?

Jarred Sumner: [00:42.] Yeah. I'm the creator of Bun. Bun is an incredibly fast all-in-one JavaScript runtime bundler, transpiler, and NPM package manager, and also package JSON scripts runner.

Chuck Carpenter: [00:55] And you're founder of Oven.

Jarred Sumner: [00:57] Yeah. And we're the company behind Bun. We raised $7 million last summer to build hosting for Oven. For Bun?

Chuck Carpenter: [01:05] Yeah. Nice. I will be curious to get into that a little bit later. I heard you mention it on a different podcast, and I was like, ah, platform. I see where you're going. Okay. This will be interesting.

Jarred Sumner: [01:15] Yeah.

Robbie Wagner: [01:16] Cool.

Chuck Carpenter: [01:17] Well, we'll start with the whiskey, though, because I'm sure that's why you're here. So today we are having the Peerless Small Batch Kentucky Straight Bourbon whiskey. Mine at least, because this is barrel proof, is 109.2 and it is not age stated. And also the mash bill is undisclosed, but they say it is a sweet mash, which to me makes me feel like it's either, like, high corn or maybe has a little wheat in there or something. But I guess we'll find out how sweet that means. All right. I like your fancy whiskey cup. So we usually start off I don't know, we come up with arbitrary, descriptors, smell it, taste it, all that kind of stuff. And eventually, what we're going to do is try to rate it on a scale of one to eight tentacles. Kind of arbitrary and subjective, but it's really based on either whiskeys you've had in the past or for us, we'll segment things into bourbon, rye, and whatever else, just because we get to try so many. And then you could say, one, this is terrible, never want to have it again. Eight, this is amazing. Nothing else will ever cross these lips. And then, obviously, everything in between. This is the gist of it, at least.

Jarred Sumner: [02:29] I'm not much of a whiskey guy, or, like, in general. I don't actually drink that much, but I would say it's like, maybe a five. It's not bad. I just don't like whiskey that much, to be honest.

Chuck Carpenter: [02:40] Yeah. There you go. Well, I'm glad we forced them on you. Thanks for being a good sport, though, and trying it anyway. So I'm going to smell it a little bit, and I feel like I'm getting a little kind of like creme brulee, but like the burnt sugar bit of it, not quite like.

Robbie Wagner: [02:55] Smells like craisins to m.

Chuck Carpenter: [02:57] There's nothing wrong with craisins tart sour. Who doesn't want that? And then, to make me look like some kind of aficionado, I just keep these glasses around. You got these things. It helps the whole experience. It makes you look good. You know what? I get notes of a weird thing kind of reminds me of, and maybe I put it in my head earlier or something, but did you have any grandparent or old uncle or whatever else that they would smoke a pipe, but it would kind of have, like, sweet-flavored tobacco in it and that smell and see, when I grew up, smoking inside was, like, a normal thing. So it's the early eighties, and Grandpa Joe is having his pipe, and it's got a kind of cherry smell to it. Tobacco cherry smell. That's what this reminds me of.

Robbie Wagner: [03:44] Yeah, I could see that.

Chuck Carpenter: [03:45] Whatever you think of that, I have pleasant memories around that.

Robbie Wagner: [03:49] Yeah.

Chuck Carpenter: [03:49] So it's not necessarily a bad thing, but it is kind of mild. It has a bit of punch and flavor in the beginning, and then it dissipates pretty quickly, and it's mostly just burn. I'm giving kind of those qualities for me. I'm kind of giving it a four, especially this one's, like a little on the pricier side and compared to a lot of things that just pack a little more depth, flavor, and don't just punch you in the gut with a burn. Four for me.

Robbie Wagner: [04:16] Yeah, I guess I'll say five. It's not bad, but I don't know. It's a little harsh, I think, for the price point.

Jarred Sumner: [04:25] Yeah.

Chuck Carpenter: [04:26] So, Jarred, it's like $100 bottle versus maybe like a $50 or $60 bottle that would provide something like a nice whiskey without being pricey and not really doing much on the palate.

Jarred Sumner: [04:38] Cool.

Chuck Carpenter: [04:39] Yeah, that's the context there. Cool. Well, let's talk about some things. Hopefully, you're more into, like, technology and code and whatever else. We have a few questions that we ask each of our guests, and just trying to get the hot takes of each person's opinion on some of these things. It's the stuff that tech Twitter wants to argue about from time to time. You go first, Robbie.

Jarred Sumner: [05:04] All right. So the first one in TypeScript. Do you use inferred types or explicit types?

Jarred Sumner: [05:10] I like inferred types. Well, it depends. Sometimes it's really nice to be explicit when it's like, this is like an API schema, and you want to very clearly see what everything is and what to expect. But I think if I'm just, like, trying to build something, I'd much rather use inferred types.

Robbie Wagner: [05:30] Cool. Yeah, I would agree with that.

Chuck Carpenter: [05:31] I dig it.

Robbie Wagner: [05:32] I don't know how much styling you typically do, but do you like Tailwind or vanilla CSS?

Jarred Sumner: [05:38] I usually use vanilla CSS, but I don't know because I used to actually do a lot of front end before Bun, but a lot of the time, it would be like these projects that I quickly built, and it would end up with a single 1000 line CSS file that just accrues. And I don't recommend that in general, but if you're just like, I need to build this thing in the next three days or something, then that's like the easiest way to do it. But I used Tailwind a little bit, but not enough, really. My sense is that if I was really focused on front end today and doing front end all the time, I probably would use Tailwind. But it's like there's like a bit of a learning curve of just like right now I'm more productive just writing old CSS level, but the way people did it before.

Robbie Wagner: [06:23] Yeah.

Chuck Carpenter: [00:25] Oh, gee. You embrace the cascade, the true cascade, which is just keep reading the file. You'll see what's going to happen.

Robbie Wagner: [06:32] Yeah. It gets scary when there's like 10,000 line CSS files, though, and you're like, I don't know what's going to break here. I'm just going to keep adding to the end. Never change the rest.

Chuck Carpenter: [06:43] Definitely never did that.

Jarred Sumner: [06:45] At a previous job. We used BEM, and that was when I write [Inaudible 00:06:51]. I still do that, but it feels weird.

Chuck Carpenter: [06:54] Yeah. Like when you talk about them, in theory, it sounds really logical, and then you start trying to do it, and then the project gets bigger, and you're like, wow, this is really convoluted and isn't as easy as I thought it was going to make things. And maybe I was just doing it wrong. It could be that too.

Jarred Sumner: [07:11] Yeah.

Robbie Wagner: [07:12] Seems like a lot of extra hoops for no reason, personally.

Chuck Carpenter: [07:17] Okay, here's the serious one. Git rebase or Git merge.

Jarred Sumner: [07:22] This is a very like, I don't like this answer, but it depends. But usually, it's like whichever one is going to make it easier for other people to review without also spending a ton of time fixing. Basically, if there's a bunch of conflicts, then rebase is always worse. If there's not that many conflicts and you intend, and the list of changes isn't actually going to be huge. The trade-off is mostly GitHub UI isn't very good when you have if there were a lot of changes in the merge, then GitHub will show all the changes for that were like other people's stuff or previous commits in the diff. And that makes the PRs impossible to read. So I would say this is mostly a GitHub bug. That this has even a question.

Chuck Carpenter: [08:14] Yeah. Because I think they both can apply during what are the specifics obviously, you're Git merging your new feature in, and Git Rebase, in a way, in general, is keeping your feature branch up to date. But what I like about Git Rebase is I feel like it forces you to have small changes that move faster because, like you said, if it goes on too long, it's such a spaghetti mess, and almost neither works well at a certain point.

Jarred Sumner: [08:41] Yeah.

Robbie Wagner: [08:42] I think the big thing for me with merge is I just don't like that it makes the extra commit that's like, you merged this. That's my nitpick, but.

Robbie Wagner: [08:52] Yeah. Merged from main.

Robbie Wagner: [08:54] Yeah.

Chuck Carpenter: [08:54] Jarred merged from main. Jarred, will you just rebase? I would be saying, what do you think about signals?

Jarred Sumner: [09:03] I don't like them.

Robbie Wagner: [09:04] Okay.

Jarred Sumner: [09:05] I don't super dislike them, but I think in most cases, most applications really do want to have everything updated in one cycle instead of extremely granular updates. And that's because it's just harder to reason about if any part of your application, any part of the rendering, can change, and you don't want screen tearing. Basically. That's not always what can happen, but it's probably easier when you're using signals. I also just like the directness of you can use destructuring without special stuff to make it work. It feels closer to JavaScript to not use signals.

Chuck Carpenter: [09:45] I see. When I was trying to look up some things around your background, I see that you spent a little bit of time at Intercom as well. Did you ever work on any Ember applications there?

Jarred Sumner: [09:56] Yeah, I worked on the invite flow in Intercom.

Chuck Carpenter: [10:01] Yeah. Did you have any feeling or feedback around the Ember framework?

Jarred Sumner: [10:05] I used Ember before I used React, and yeah, this was before they had, like, proxies, so you had to use, I think, they had a proxies later. That was after I started using it. So you had to, like, dot get, and then you had to pass it like the dependencies or is it dependencies, or it's been a little while. Definitely pass a string with the property name. And it was really nice to not have to do that anymore after React. It was also just felt like a lot of code. I think Ember was good in the time it was created, but React was just easier.

Chuck Carpenter: [10:40] Yeah. I don't think there's any necessarily wrong or right answers around these things, but I'm curious because you've had your hands on lots of different things. I like hearing some different perspectives. Really.

Jarred Sumner: [10:50] Yeah. That makes sense. Yeah. And I think I would probably use my default, really? Is React?

Chuck Carpenter: [10:56] Yeah.

Jarred Sumner: [10:56] I think it's good to try other things, though.

Chuck Carpenter: [10:58] Yeah. Get some context and understand what's still working for you or what isn't sometimes.

Robbie Wagner: [11:04] Yeah.

Chuck Carpenter: [11:05] Kind of like if you decide to create, I don't know, a whole new bundler, right? And maybe something wasn't working for you, and you go down this path. Let's get to the real reason why we're here.

Jarred Sumner: [11:16] Yeah. We're actually about to ship a whole new bundler. We're getting really close. That's what I've been really focused on. Really what we've been really focused on most people on the team, and basically, the plan there is esbuild plugins work in Bun's new bundler for the happy path case. Esbuild plugins run about five times faster, and that's like end-to-end build time. That's not like the plug-in execution time. So that's like more stuff that runs faster. The actual plugins themselves run faster than that. But the thing that people care about is not how fast one part runs. They care about how fast the entire build is.

Chuck Carpenter: [11:54] Yeah, and for some context there, when you say five times faster, what are you benchmarking against specifically?

Jarred Sumner: [12:00] In this particular case, if you have, like, a YAML loader as a plugin and you import it like a big YAML file, so then that has to be that runs the YAML loader to convert it to JavaScript, and then the transpiler then runs on that converted JavaScript file and then exports it, then creates a bundle. And that one is five times faster. And it's like using YAML JS and then also different. It's running in Bun's runtime versus running in Node's runtime in the esbuild case. But I don't imagine the difference between the YAML parser performance itself is that big. Between the runtimes, it's mostly just the overhead of plugins and a bunch of optimization work.

Chuck Carpenter: [12:40] Yeah, so really like a big change from like you were mentioning like the runtime of versus Node probably versus Deno, those kinds of things. And that's most of the benchmarks that I'll kind of see within your docs and on the site in various places, you'll say this thing here, and then you're looking at do this operation, here it is in Bun, here it is in Node, here it is in Deno. So that's kind of what you're always looking for looking at for those benchmarks.

Jarred Sumner: [13:05] In this particular case, we're going to start doing more benchmarks with bundlers because we really want people to use Bun as a bundler in addition to a runtime. And so, with a bundler API, it's just one function in Bun. Just Bun.build, and it's built-in. It returns a promise. The first version is going to just be ESM only. We're going to do other formats, too. We'll do IIFE little bit later.

Robbie Wagner: [13:31] So, for someone that has no idea how to build a bundler or how any of this stuff works, how do you continue to make things so much faster? Is it like the core code is just way faster, or is it like, on a case by case you want to implement a thing, you see how fast it's running elsewhere and just find where they've fallen short and improve that, or how does that work?

Jarred Sumner:[13:55] It really depends. But the pattern, I would say, is one thing that we do a lot of that I think is harder to do in other cases, or it's just really more, it makes the code more tedious is we pre-allocate, almost everything. So when there's like a big array of something, then instead of pushing the array dynamically, we set up, we do one pass to count the length, and then we do one allocation. Because usually, not usually, but in a lot of cases, the thing that is slow is reallocating data repeatedly as the size changes over time. Another thing is pretty much all of Bun is written in Zig, and there's a lot of things that, and usually the other tools, are written in JavaScript. In this case, I guess if we're comparing esbuild then it's Go. But another thing that we do a lot of is SIM or SIMD, which stands for single instruction multiple data, I think. But basically, there's a bunch of CPU instructions that let you operate onboard data at once. Normally if you're reading through a string, you're looping character by character. In a lot of cases, fun will loop through eight characters at a time, 16 characters at a time, something sometimes more than that. And when you use SIM, you can have those same it's like slightly slower in terms versus one character as a one instruction, but it's one instruction instead of eight.

Robbie Wagner: [15:16] Right.

Jarred Sumner: [15:17] So that's an example there that was this is high impact for when we do text encoding and text decoding. Like if you do like buffer dot two string, the code in there eventually uses SIMD, and that makes it multiple times faster than in Node, and we do just a lot of that.

Robbie Wagner: [15:36] Got you. And then, yeah, you mentioned Zig. What was the motivation there? I feel like most people had kind of not heard of it until you dropped Bun, and they're like, what is this new thing that he's using here? A lot of people are using Rust or something like that for things these days. What brought you to Zig, and had you used it before, or were you just kind of looking for something really performant?

Jarred Sumner: [15:58] So Bun was actually my first project in Zig, and we took a really big bet, and I still think it was great that we just took that bet on Zig and just Zig is really productive. I tried to use Rust, and I just had a lot of trouble being productive. And Zig is a really good trade-off between low-level and sort of like C but with a little bit better safety features like bounce checks in arrays and alignment checks and integer overflow detection, integer underflow, that sort of thing. While also just being really productive and having and also comp time is really cool. It's this idea that you can execute almost any of the code at compile time, and then it will just become part of the rest of the code. And so we move a lot of work that would normally happen at Runtime to happen at compile time. Like we have hash tables that are entirely, entirely exist at compile time instead of the overhead of creating a hash table at runtime. And they also do give you really fine grade control over memory allocation. And normally, memory allocation is like the thing that makes everything slow. So by having fine-grain control over that, we can make a bunch of stuff faster and have specialized memory allocators. Like the JavaScript parser has its own memory allocator.

Chuck Carpenter: [17:14] Yeah, that's one of the biggest things I've heard you mention in previous podcasts around. Some people might see that as a downside, having to deal with memory allocation, garbage collection, all those things on its own. But you were saying, though, it basically encourages you to determine your memory early and keep it small, and then that kind of helps the rest of that maintenance throughout.

Jarred Sumner: [17:36] Yeah, that is a big part of it, too, is also if you can reduce the amount of memory that's in use. Normally a lot of the time, people think performance the performance of real applications is like I/O bound, and it is in the case of we are waiting for a network request, but usually, there's just so much overhead that is CPU bound. And for CPUs, the thing that's slow is usually it's not actually the processing. It's memory. It's because the memory latency is pretty high relative to how long in a lot of cases. If you make something smaller, you end up making it faster too. Smaller in terms of memory usage.

Chuck Carpenter: [18:12] Yeah, that makes sense.

Robbie Wagner: [18:14] Yeah, someone should tell Chrome about that. Stop using so much memory.

Chuck Carpenter: [18:18] Yeah, it doesn't have some little flag now, though, where you can turn on some little memory management thing where it won't have such long-running things because so many people don't close tabs and don't close browsers ever.

Robbie Wagner: [18:29] Yeah, I think they have a thing that's like the tabs run in the background, or they just don't run all the time anymore or something.

Chuck Carpenter: [18:35] So what we need to do is create a new browser in Zig. I don't know. I don't know if I could do it, but.

Jarred Sumner: [18:43] It needs somebody who worries about something that is a massive amount of work. A web browser is like a whole other thing.

Chuck Carpenter: [18:50] Yeah, right. Yeah, well, I mean, you are going to keep making things, and part of that is going to be a hosting product, and I don't know how much you can tell us early days and all that kind of stuff, but I'd be very.

Jarred Sumner: [19:01] It's really early.

Chuck Carpenter: [19:01] Yeah.

Jarred Sumner: [19:01] But I can talk a little bit about it.

Chuck Carpenter: [19:03] Yeah, I'd love to hear what you can.

Jarred Sumner: [19:05] I'm going to caveat this with, like, all of this might change. It's still very early. Kind of the plan there, though, is we want to have slow double-digit millisecond start time, maybe single-digit millisecond start time for most apps. And we're going to have JavaScript core VMs JavaScript, the engine that one uses. For comparison, Vite is the engine that Node uses. And the plan basically is we're going to run like thousands or more of these on individual servers where each instance is like a user's application. It's going to deploy everything on demand. We're still debating on whether to do whether there's going to be a build step or not or whether we would just run the build as part of the deploy process, like as part of starting up every single time. The status quo with Bun is that it builds every file when you start it. But if you're redeploying the same application multiple times, it seems like it's going to be pretty wasteful. However, it might end up still being cheaper than the process of having a build step waiting for the build to complete, and uploading the build to the server. We just need to run a bunch of experiments to answer that. The plan there is also we're going to have servers in data centers. We're not going to use public clouds for the hosting. And I think that's going to be a really important part of making it fast and making it cheap because I think it's also kind of philosophically. Bun kind of embraces not invented here syndrome, where normally it's like, a bad thing to, like, oh, this is not the core part of your thing, so you should go and use an existing tool, but you can get a lot of value out of building it yourself, and you can make it a lot better. And it's not for everybody, but in our case, I think it's what we do.

Chuck Carpenter: [20:52] It sounds like your personal mantra. If I was to just based on what I know about you, what we've talked about here, what you've talked about in other places, you're like, no, I can make it myself.

Jarred Sumner: [21:04] It's like as the time goes on and there's so many bugs that we need to fix, I become a little bit more reluctant on it because just like there's so many. In Bun, we have a custom http client, and okay, there's some bug recently with TLS handshaking, and all right, now we got to port the code from this is really obscure, and we have to report some code that we saw in Chromium to make it work correctly and fun, so that way it behaves consistently with web browser. But I'm very aware of the cost of building it yourself. And so we're a little bit more careful now.

Chuck Carpenter: [21:43] Right? And you're thinking about more people than yourself. You're thinking about a company and other people making decisions and being a part of that. And while you could have put heads down and maybe gone off and fix some one-off problem, you got to think about overall growth and trajectory and keeping these things going forward. So that makes a lot of sense. I still would have, like, printed you up a t-shirt that says there's something about just making it yourself. And I could see that you just wear that conferences. It would make sense to everyone.

Jarred Sumner:[22:13] Yeah.

Chuck Carpenter: [22:15] Anyway, that was more comment than questions. Sorry about that. But it does help give me a little something because in my mind, when I heard you mention it before, I was thinking like, okay, so they're going to do their version of Vercel with this different engine and its UI, but also some different underlying technologies. But if it's really ground up, I can see where there's a lot of different opportunities there. And it's not just like, yeah, Amazon console sucks. So we made it better, and then we put our proprietary product in there to do this serverless thing with apps and whatever else. But I mean, this is completely different. So I'm excited about that.

Jarred Sumner: [22:52] I really see Oven as an infrastructure company and that we're building Internet infrastructure. And I think that we can make the Internet and JavaScript applications faster, and we can make it easier to deploy, and we can make it better. It's going to be a lot of work, but it's going to be really fun.

Chuck Carpenter: [23:09] Yeah, I'm glad you're enjoying it because, in my purview, you seem to be doing a lot of work. You're both simultaneously constantly working on features in Bun and whatever else and also tweeting constantly. Well, so many tweets. So it's good that you're able to do those things at the same time. But actually, I want to regress slightly to something you were just saying there, like making the Internet better. But my question is, can you make the Internet more fun and weird?

Jarred Sumner: [23:36] Yeah, that was kind of before for more context. Before Bun, when I was there was this blog post I wrote, why isn't the Internet more fun and weird? And kind of talking about how it used to be that you could edit CSS on websites and that we sort of today have. The Internet is like a bunch of polished boxes that are handed to us. And there's no like people used to be able to repair things on physical things that they bought that also used to extend to the Internet where you had CSS. You could tweak it. In the MySpace case, it was actually an accident. There was like a bug that let you edit CSS. And I realized that people actually wanted to use that or wanted to do that, and they were like, oh, this is a feature, not a bug.

Chuck Carpenter: [24:25] Right. Yeah.

Jarred Sumner: [24:26] I still think about this a lot. I don't really know yet how it would fit with how it's going to fit with Oven and hosting, but I definitely want to encourage have that spirit.

Robbie Wagner: [24:37] Yeah, I would fully support making MySpace again, just for the record, because that was so fun.

Chuck Carpenter: [24:43] Buy it from Timberlake. I'm sure it's cheap. So for context listener, yeah, Jarred mentioned that he wrote this article in the context there. Being around, like, the Internet was kind of for everyone. You could come there, and there were places where you could have your own space. I mean, prior to that, you had things like GeoCities or whatever else, where you could have your own little hosted website space that you could personalize with some basic HTML and CSS, and CNET would give you basic HTML lessons and stuff, too. So it was approachable and kind of for everyone to some degree. And basically, where the Internet, as many things do, become about money and services and apps versus spaces or sites or whatever else, there's a real void in that, right? Like the fun parts where you could go and say, yeah, I have my local soccer team, and I want to make a little space for it. Or I remember when I was younger, my brother played this game, Tribes, and he loved it so much and he set up his own GeoCities site for Tribes and his tribe that he had created online. Their whole kind of vibe, I guess, that really isn't kind of there anymore. There's forums, there's Reddits, but everything is so super organized and less personal. I actually really enjoyed reading that article and seeing that, and made me think as well that is a void kind of in the Internet. We're all like, what app can we make? What thing can we fix for people? And, okay, how do we make sure they stay within our box so that we don't risk security and personal information and credit cards and all this very serious stuff, which applies to certain bits? But yeah, where's the fun?

Jarred Sumner: [26:23] Yeah, I think part of it, too, is that part of it is like the solver us, we're older, and the people we were at that time we're different now. And I think today, a lot of this energy is kind of moved to Roblox. So they're not like websites. They're like different boxes, I guess. I do think Roblox has done a very good job of it, but it's still not like websites. It's not the same public nest of a website.

Chuck Carpenter: [26:53] Right. But they maybe identified a bridge there a little bit, and then again, they're commoditizing it. And so that's where probably some of the creativity gets lost to a degree. You can be creative within their context, but you can't really like, do whatever you want.

Jarred Sumner: [27:09] Yeah.

Chuck Carpenter: [27:09] Here's a spot. Do whatever you want. That's an interesting thing. Anyway, I was just trying to dig in and see what you've been up to, and I came across that, and I was like, this is interesting. I wish you had written more than one of these blog posts.

Jarred Sumner: [27:20] It was a lot of work. I wrote that blog post, like, in 2019, I think. Yeah, it was like, I think it was like three weeks of work. It was around the time that I'd left Stripe, or just before that, and I was going to build a product around that, and then I tried it and didn't.

Chuck Carpenter: [27:36] It's hard.

Jarred Sumner: [27:37] Yeah.

Chuck Carpenter: [27:37] Right. Yeah. First or second time you left Stripe?

Jarred Sumner: [27:41] That was the second time.

Chuck Carpenter: [27:42] Got you okay? You were like. I'm done. I'm out.

Jarred Sumner: [27:46] I really like working there, but I felt like I'm just a person who likes building things a lot, and I'm not very good at working at large companies.

Chuck Carpenter: [27:55] That's fair. It's completely reasonable. So we started to talk about Twitter for a second, and I'm only going to ask this just because this was a previous guest listener question without outing anybody. So yes, lots of tweets out there. Would you be willing to read one of your draft tweets?

Jarred Sumner: [28:14] Honestly? Let me see if they have any interesting ones.

Chuck Carpenter: [28:17] It can be an uninteresting one. And then it satisfies the requirement. As long as it's in draft, it's sort of like a win. There's no pressure on this show. That's what's good about it.

Robbie Wagner: [28:25] Yeah. You can draft one right now and say anything you want.

Chuck Carpenter: [28:28] Yeah, you can make it up. I quit. Oh, wait, no.

Jarred Sumner: [28:33] One of them was. I used to spend 15 minutes clicking around before every release of Bun.

Chuck Carpenter: [28:37] Yeah. Okay. I like it.

Jarred Sumner: [28:39] Another one is, Please do ship your TypeScript source. It was a quote in response to one of the people who work on TypeScript saying that TypeScript package containers, please do not ship your TypeScript source and TS config in your package.

Chuck Carpenter: [28:55] Yeah, bad advice. Ship it.

Jarred Sumner: [28:58] The reason why mostly is because if you ship the source file, then your tooling is better able to optimize it because once it's been transpiled, then the tooling, it's like a bunch of information is lost.

Chuck Carpenter: [29:12] Right.

Jarred Sumner: [29:12] But of course, the trade-off is that you have to transpile it. And in Bun's case, selfishly, we transpile every Node module. And this happens regardless of whether or not it's a JavaScript file or types of file. So it's good for us. But it's also easier for people because you don't have to have a build set before you publish. You just publish.

Chuck Carpenter: [29:32] Yes.

Jarred Sumner: [29:32] And it also means that you don't have to worry about TypeScript declaration files. It'll show up in your editor because it's a TypeScript file.

Chuck Carpenter: [29:40] Yeah, that's nice. I like that. I love that.

Robbie Wagner: [29:42] Yeah. If they would just make TypeScript able to run everywhere, then we wouldn't have this problem anyway.

Jarred Sumner: [29:47] Yeah.

Chuck Carpenter: [29:49] It's a made-up language, Robbie. It's made up. Might as well be CoffeeScript.

Robbie Wagner: [29:53] No, don't take me back to CoffeeScript.

Chuck Carpenter: [29:58] Anyway.

Jarred Sumner: [29:59] Those were bad days.

Chuck Carpenter: [30:01] We've had this debate in the past. It wasn't that bad. It was better when it became real.

Robbie Wagner: [30:06] It had good ideas, which are now part of JavaScript. So I appreciate it for that.

Chuck Carpenter: [30:10] Yes. There we go.

Robbie Wagner: [30:12] Should we just move into, like, so we obviously know you probably spend most of your time running your company and writing code and whatever. Do you do any other hobbies or anything like that?

Jarred Sumner: [30:23] The only other thing I really do is just run. But I'm not good at it. It makes me happier.

Chuck Carpenter: [30:30] I mean, unless you are trying to run a race, I don't think you can really be bad at running. Right?

Jarred Sumner: [30:36] Yea, that's true.

Robbie Wagner: [30:37] There's always someone that's worse than you at running.

Chuck Carpenter: [30:40] I just feel like that's subjective. Right. Anyway, because running is such a solo activity. So as long as you're feeling good at it, about it, and you feel good afterwards, then you're good at running. If you feel like you are dying and your knees are falling apart, well, maybe you're bad at running. I don't know. You should do more of it or try another sport. But unless you're in a competitive situation where you are against that, then I don't know, you're good at it. I'm just trying to support you, Jarred, and just give you a little kudos. You're not bad at it. You're just fine. It makes you happy. So what's the last movie you've seen?

Jarred Sumner: [31:16] I can't remember. It was probably one of the superhero movies.

Robbie Wagner: [31:19] Okay.

Jarred Sumner: [31:19] It's like on Disney Plus.

Robbie Wagner: [31:21] Like a Marvel.

Chuck Carpenter: [31:22] Yeah, Marvel. Then I was going to ask you DC or Marvel be kind of where it goes. Those are where they're.

Jarred Sumner: [31:27] Actually, the last one was I saw the I watched it over, like, three nights because I kept falling asleep. But Ryan the Snyder, I don't know his last name.

Chuck Carpenter: [31:37] Oh, Zack Snyder's.

Jarred Sumner: [31:39] Yeah.

Chuck Carpenter: [31:39] The Justice League to Zack Snyder, editor.

Jarred Sumner: [31:41] Yeah.

Chuck Carpenter: [31:42] Well, that's like three and a half hours. So that makes total sense if you start it at night, and then you're like, oh, my gosh.

Robbie Wagner: [31:48] And it's all black and white. Yeah.

Chuck Carpenter: [31:50] Right. Yeah, so that makes sense. Okay, so you don't mind Disney Plus or some Batmanny kind of things. Actually, yeah, I liked that one. I'm a little equal on both superhero universes.

Jarred Sumner: [32:03] I think I like Marvel better. Yeah, because it's happier.

Chuck Carpenter: [32:06] I was a Spiderman fan as a kid. Yeah, there's a lot more jokes. Right? It's like, I think I heard this in a Kevin Smith interview or somebody recently who's in the comic world, and they were like, yeah, Marvel is the one where they make kind of sarcastic jokes a bunch. And DC are the straight edge.

Jarred Sumner: [32:23] Yeah.

Chuck Carpenter: [32:24] Food for thought there.

Robbie Wagner: [32:25] I guess Batman doesn't joke.

Chuck Carpenter: [32:27] Not really. He's very serious. His parents were murdered in front of him. He's just trying to.

Robbie Wagner: [32:33] No joy left in his life.

Chuck Carpenter: [32:34] Yeah. He's spending his billions, and he's just trying to keep it going. Robbie, he stays up all night.

Robbie Wagner: [32:41] That's true.

Chuck Carpenter: [32:43] Right. Spiderman lives with his Aunt May and has apple pies or something. I don't know.

Robbie Wagner: [32:47] Yeah. And his life's harder because he has to work out and have technology for his like. He doesn't have superpowers. Superman is just like, oh, I can just fly and whatever. And that's easier, right?

Chuck Carpenter: [33:00] Indeed.

Jarred Sumner: [33:01] Batman earned it.

Chuck Carpenter: [33:02] Yeah, that's true. I read comics and stuff as a kid, too, and I loved the Frank Miller stories around Batman, where he's aging Batman and kind of what's happening there because inevitable at some point, right? Where do you go?

Robbie Wagner: [33:15] No, Batman doesn't age.

Jarred Sumner: [33:16] I saw some of Batman Beyond a while ago, and that's like the future Batman cartoon. And yeah, it has a similar, I don't know if. I haven't watched the aging Batman you described, but they showed him as old, and it's interesting.

Chuck Carpenter: [33:34] Yeah. The next-gen of someone else who also had to work out. I mean, he basically just had to end up with a benefactor, though, right? Because Wayne Industries has the billions and all this equipment and constant military-level equipment that gets pulled into his whole deal, and he gets too old to use it. Next dude has to get that cash, I guess. That's the next start. Can you help me get some VC funding around that, like Vigilante?

Robbie Wagner: [34:02] Building real Batman.

Chuck Carpenter: [34:03] Yeah. Build real Batman. Real Batman.io. I don't know. It's probably a reason why I don't own a company. You do. So there's that.

Jarred Sumner: [34:13] I wonder if we will do, like, Jetpacks and those things. It'd be really cool.

Chuck Carpenter: [34:18] Yeah. I'm just waiting on the flying car. It's all about the flying car.

Robbie Wagner: [34:21] They've been talking about the flying car forever. They could totally do it now, but they still don't for whatever reason.

Chuck Carpenter: [34:28] Well, they're trying to get autonomous on roads and then forget the roads.

Robbie Wagner: [34:32] There's less stuff to hit in the sky.

Chuck Carpenter: [34:34] Yeah. Wasn't that the end of Back to the Future?

Jarred Sumner: [34:37] But you have to constantly be worried about, like, are the cars going to fall on me?

Chuck Carpenter: [34:42] Yeah.

Robbie Wagner: [34:43] Oh, that, yeah, I didn't think about people below the car.

Chuck Carpenter: [34:46] Nobody walks anymore, for sure.

Robbie Wagner: [34:49] Yeah.

Jarred Sumner: [34:50] I feel like underground is more likely.

Chuck Carpenter: [34:52] Yeah, I can see that. If the surface heats up too much, then underground is a natural progression. We've done that. We've built things underground. So kind of go down, but not too far because that's closer to something else.

Jarred Sumner: [35:06] But also because you don't have to worry about flying cars, like cars flying into buildings or there's a very clear highway because it's just underground and there's very clear constraints for.

Chuck Carpenter: [35:18] Oh, the flying car goes underground. Okay.

Jarred Sumner: [35:21] Yeah.

Chuck Carpenter: [35:21] I conflated those and thought that the people go underground. But we do need sun to a degree. Right? Like we're supposed to get some things from like fresh air and sun and all that, without getting cancer.

Robbie Wagner: [35:34] Yeah. What?

Chuck Carpenter: [35:35] We're all getting cancer, though. Doesn't matter.

Robbie Wagner: [35:37] Wasn't that, like, I don't exactly remember the context, but I don't know if it was Hyperloop or just like something that they were building where you could drive your Tesla into a thing that would then go underground and take you somewhere.

Chuck Carpenter: [35:50] The Hyperloop was going to use a special train kind of thing, and essentially it was going to turn, like, La to San Francisco into a 45 minutes.

Robbie Wagner: [35:58] Yeah.

Chuck Carpenter: [35:58] But it wasn't your car.

Robbie Wagner: [35:59] Did you see the thing with the car, though?

Chuck Carpenter: [36:02] No.

Robbie Wagner: [36:02] There was one with the car.

Jarred Sumner: [36:04] Yeah, I think there was a tunnel thing. Boring tunnel. Boring. I don't understand.

Chuck Carpenter: [36:09] Yeah, the Boring Company is his whole tunnel thing.

Robbie Wagner: [36:13] Yeah, the flamethrowers.

Chuck Carpenter: [36:15] Yeah. You didn't get a flamethrower?

Robbie Wagner: [36:18] I didn't know, no.

Chuck Carpenter: [36:20] Me either. I don't know what I would do with that, but it's funny, I guess.

Robbie Wagner: [36:24] Yeah.

Chuck Carpenter: [36:24] The Boring Company is the one that kind of makes the tunnels, and the Hyperloop was supposed to be the whole use physics to shoot you much faster on that whole trip. But I don't know.

Jarred Sumner: [36:37] It sounds dangerous. I would not be the first one in the hyperloop, I don't think.

Chuck Carpenter: [36:43] Save that for the monkeys. We always test out things on monkeys.

Jarred Sumner: [36:46] If it works, that would be really cool.

Chuck Carpenter: [36:47] Oh, yeah, it would be super cool. You're in San Francisco, right?

Jarred Sumner: [36:51] Yeah.

Chuck Carpenter: [36:52] And then if you needed to go down to La, zoom hyperloop. It's a way to do it.

Jarred Sumner: [36:57] Yeah.

Chuck Carpenter: [36:58] I'm in the desert. We don't go anywhere.

Robbie Wagner: [36:59] Yeah, I thought it was cool because I think it was DC to New York was, like, 30 minutes or less or something. So you could literally be in DC. And be like, let's go to this restaurant in New York for dinner, and you could do it. That's crazy.

Chuck Carpenter: [37:12] Make your reservation and get there on time. That'd be pretty nice.

Robbie Wagner: [37:15] Yeah.

Chuck Carpenter: [37:16] Because the fastest train is two and a half hours.

Robbie Wagner: [37:19] Yeah.

Jarred Sumner: [37:19] It also would make remote work way better.

Robbie Wagner: [37:22] Oh, yeah.

Chuck Carpenter: [37:22] That's true, too. Yeah. I mean, I think that's what its intention is. It's trying to bring efficiencies around commutes back and forth and that stuff. I mean, at the time when he was talking about that, right? There's been a pretty decent tech build-up in La, and obviously, San Francisco is the heart of it all. And so connecting those two behooves quite a bit. All that entertainment tech that's in La now.

Jarred Sumner: [37:45] Yeah.

Robbie Wagner: [37:46] You got to connect the Netflix offices, at least. I guess that's not San Francisco, for one.

Chuck Carpenter: [37:52] Yeah, it's, like, a little bit outside. Right. But I don't know. Maybe there's just where do you get to do stops or where can you get on? And where does that all kind of apply?

Robbie Wagner: [38:01] It can't stop. It's too fast.

Chuck Carpenter: [38:02] Yeah, that's the point that it doesn't stop. That's why it works. It's momentum based. Well, there's a reason why I'm not working on that project as well. I'm not selling myself well as an asset here, but I can tell you that that kind of engineering isn't for me.

Robbie Wagner: [38:20] Didn't they use some Node stuff in the rockets? I think there was something JavaScript based that was.

Jarred Sumner: [38:30]I think they use Chromium.

Chuck Carpenter: [38:31] Yeah.

Jarred Sumner: [38:32] Like for the UI.

Robbie Wagner: [38:33] Okay. Yeah. Because it's like if there's some JavaScript in there, then we all have a chance to build whatever we want.

Chuck Carpenter: [38:43] That's true. Not everything is Java or C++.

Jarred Sumner: [38:47] Yeah.

Chuck Carpenter: [38:48] Food for thought there. All right, so we talked about your hobbies. What other developers or projects do you find interesting, or is there any other recent developments that you have started to follow?

Jarred Sumner: [39:03] I think Elysia JS is really cool. It's a fun web framework. They're doing a great job with it. It's really fast. If you run Elysia JS on, like, twelve cores and you run Actix, I think that's the name of that the popular Rust web framework on twelve cores, then the performance is basically the same.

Chuck Carpenter: [39:21] Wow.

Jarred Sumner: [39:22] Of course, Elysia is in TypeScript and Actix as in Rust, and this is like in a Hello World benchmark, to be clear, and the DX is good, and they spend a lot of time on it.

Chuck Carpenter: [39:34] Elysia.js, you said. And then I don't know if you could.

Jarred Sumner: [39:38] Yeah, if you Google Elysia.js, it's like the first result. E-L-Y-S-I-A.js.

Chuck Carpenter: [39:45] Okay, there you go. I was like. I'm going to need some spelling here because I'm thinking about A.

Robbie Wagner: [39:49] There's a lot of ways to spell that.

Chuck Carpenter: [39:51] Aly. Yeah, cool. Thank you. I would check that out. That'd be interesting. I played with a little bit a couple of the WASM Rust Frameworks just to look at that from, like, oh, a web application standpoint and something that ends up in web components or whatever but cut out the middleman. Right?

Robbie Wagner: [40:08] Yeah. If you can run JavaScript and it's anywhere close to as fast as Rust, that's a huge win.

Jarred Sumner: [40:14] Yeah. And I think, generally speaking, if your application is a bunch of or is, like, very I/O heavy, then that's something where the JavaScript runtime can really make it fast versus the JavaScript engine because there's specialized system calls. Like, the operating system does a lot of work, has a lot of different ways to optimize specific things. So when the APIs are somewhat high level, which means they're easier to optimize because they're very specific. So, like, in Buzz case, the HTTP server uses a web standard response object. If you return a file, you can do return button file and then pass or return new response bund file, then pass, and that would return to a Blob, like a web standard Blob object, but it's a lazy Blob, and the web server recognizes that you're trying to stream a file. So then, instead of reading the file manually and then writing the file manually to the socket, it uses the send file system call. And that makes it much faster because it happens, the copying stuff happens in the kernel. So kind of what I was saying earlier about the shipping TypeScript libraries, there's the same similar sort of idea that when you're closer to the source of truth, then you can make it faster, you can make it better, and you can also make it simpler by not having to have this extra step.

Chuck Carpenter: [41:34] Yeah, that makes a lot of sense. Yeah, I appreciate the way you're able to explain those things, too, to more laymanesque folks who aren't operating on those levels and working on those specific things. That does make it kind of clear. It's really just some new ways to think about dealing with those things in a web context, too. And, like, maybe less stops along the way is basically how I'm reading it. Let's cut out the number of stops.

Jarred Sumner: [41:59] Yeah, totally.

Chuck Carpenter: [42:00] Okay, that makes a lot of sense. That seems really cool. So looking forward to maybe playing with some of that.

Robbie Wagner: [42:06] Yeah, I think that was a big thing in some of the open source stuff we had done, like Shepherd, like trying to figure out what to transpile and whatnot, and I guess it's not TypeScript right now, but just like all of these extra steps. Whereas if we kind of all agreed on just ship kind of raw stuff where your bundler is going to run Babel on everything, it's going to run like a TypeScript compiler on everything, like all the stuff, then we can all just kind of ship what we write it in. We don't have to worry about, oh, I need all these different disk files and all these different declaration files for TypeScript and everything, and it'll just work. I can just assume it will work in the end application.

Jarred Sumner: [42:46] And another part of that matrix of things to worry about is like commonJS versus ES Module and packages on exports and which condition to use and all that stuff. There's just way too much complexity. And the complexity is there for a good reason. It's because we have a mature ecosystem. People built real things, and those things need to work. But it makes the day-to-day more challenging.

Robbie Wagner: [43:12] Yeah, for sure.

Chuck Carpenter: [43:13] And then you mentioned DX a little bit previously, too, in that if I can get all of the package and I need to dig through and understand what some compiled code is doing. If you were shipping the source in that way, the TS source A, I could use it in more advanced systems, but in even some of today's and more less advanced systems, I've got a problem, and I've got to dig through some compiled code, and sometimes that's pretty challenging to get through and understand what's going on. Readability, I think, is a good part of DX. And if I'm getting it all, I can read things and understand more about my dependencies.

Jarred Sumner: [43:49] Yeah, totally. In Bun's case, when we're doing the transpilation, if you throw an error because every file is transpired, the challenge errors. We also generate memory source maps of everything. So that way when an exception is raised, you don't see, like, the transpile source. You see the original source code. And we also show a few lines below and above the exception where the exception happened. It's kind of weird because how that actually is implemented. We don't keep a copy of the original source in memory. We just retranspile it a second time to get the mappings. And that's part of the thing of getting part of why Bun needs to be fast. When the performance of these things is good enough, you can just do it like the stupid way.

Chuck Carpenter: [44:33] Right.

Robbie Wagner: [44:33] Yeah.

Chuck Carpenter: [44:34] I don't even know if I think it's stupid. I think I should think it's pretty clever based on, in the back of your mind, memory management is always the thing. And so you're like, what else do I need to do to get this? I don't need to already have it because it's so fast. Just in time. Compiling, boom, boom, boom. Now we'll make this smart and give it a little more information so I can see that train of thought being very connected, actually.

Jarred Sumner: [44:59] Yeah, but it's also like because I feel like it's when somebody looks at this, they would think like, oh, why you should obviously just cache this. It sounds very cachable.

Chuck Carpenter: [45:09] Right.

Jarred Sumner: [45:10] This is the thing we're going to actually experiment with after we ship the bundler is because right now, we only transpile every file. We might try bundling every file, like bundling the entire app ahead of time at start. There's some differences there with some things will need to be virtualized, like import meta needs to be like an object instead of the actual import meta. But it might also fix some bugs. Like there's some edge cases that we still haven't fixed with CommonJS and ESM, interrupt that need to be fixed, and either we're going to fix it that way or find some other way to fix it. And also, it would mean the downside of this approach is that that's a case actually where we should potentially cache because for larger apps then, because otherwise, they're going to be reading 30 files immediately or whatever. But yeah, it's something we need to experiment with, which we can since we're about to have a fast new bundler.

Robbie Wagner: [45:59] Yeah, I do think in some cases people over cache, and especially if it's a smaller file, is it actually quicker to cache it, or should you just recompile and ship it? Because you would have to do benchmarks, I guess, of both cases or whatever. But at work, we have this one file that's like five lines of CSS that we're caching in fastly. And I'm like, Why? It depends on the file, and it depends on the use case. And I think some people are kind of in just cache all the time mode and you should challenge that and figure out what's the better solution.

Jarred Sumner: [46:36] Yeah, there are a lot of real cases where caching makes something slower because the thing you're caching is actually pretty quick to regenerate.

Chuck Carpenter: [46:44] Right. There's also the case where, you know, the thing about cache where it rules everything around me.

Robbie Wagner: [46:50] I knew you were going to say that.

Chuck Carpenter: [46:54] It's one of my favorite kind of nerd hip-hop crossovers. I don't know. I love it. And but and just in general, though, they say, like do hardest things in software and naming things in cache.

Jarred Sumner: [47:05] There's a really good blog post on from 2020, I think. Also so weird that sounds like it's in the abstract. 2020 still sounds like it's the future. Absolutely. Not. But about Mozilla Firefox's browser caches are sometimes slower than just like, the Raw network, like getting like reading the data uncached. That is such an interesting trade-off of when to cache.

Chuck Carpenter: [47:34] Yeah, there you go mentioning there. There's so many layers where that can occur. Right? It's like, where's the place for this thing? For this thing? Separating things out, putting them all together. It's still a complex problem because it's funny when you think about it, right? 2020 kind of sounds like the future, but we're in the 20s now. But the Internet is really not that old.

Robbie Wagner: [47:59] But it moves exponentially.

Chuck Carpenter: [48:02] Yeah. I mean, it seems to be hitting a speed increase or whatever. It's in a Hyperloop. Sure, I get that. But still, there's so many things to continue to figure out and improve and change your thinking on and whatever else. I just always kind of feel like, at the end of the day, there isn't really one right answer. There's probably some better answers and some worse answers, but there's definitely not one right answer.

Robbie Wagner: [48:27] Yeah, I think that's fair. All right, we are about at time here. Is there anything that we missed covering or anything you want to plug before we end?

Jarred Sumner: [48:37] We're hiring. We're hiring Zig, C, and C++ engineers to make Oven and for building our hosting platform. It's going to be one of the things we need to do is figure out how we're going to actually manage the software for the hypervisor, for managing all of these JavaScript VMs securely and efficiently and making deploys fast. I think it's going to be really fun to work on.

Chuck Carpenter: [48:59] Is there a large Zig community, or would you invite others? Is there a similar line of experience that you think translates well?

Jarred Sumner: [49:07] Yeah. So anybody? If you were familiar with C or C++, you can learn Zig really quickly. Zig doesn't actually have that much syntax. There's typically only one way to do things, so it makes it quick to learn if you have an existing background with manual memory management.

Chuck Carpenter: [49:23] Excellent.

Jarred Sumner: [49:24] Yeah.

Robbie Wagner: [49:24] Appreciate that. If you've written your own Malik, apply.

Jarred Sumner: [49:29] Yes.

Robbie Wagner: [49:32] All right. Thanks, everybody, for listening. If you liked it, please subscribe, leave us some ratings and reviews, and we will catch you next time.

Chuck Carpenter: [49:42] Thanks for listening to Whiskey Web and Whatnot. This podcast is brought to you by Ship Shape and produced by Podcast Royale. If you like this episode, consider sharing it with a friend or two and leave us a rating, maybe a review. As long as it's good.

Robbie Wagner: [49:57] You can subscribe to future episodes on Apple, Spotify, or wherever you get your podcasts. For more info about Ship Shape and this show, check out our website at shipshape.io.