DevTools showcase: Warp, Graphite, and Reflex

Captions provided by White Coat Captioning (https://whitecoatcaptioning.com/). Communication Access Realtime Translation (CART) is provided in order to facilitate communication accessibility and may not be a totally verbatim record of the proceedings.

JASON LENGSTORF: Hello, everyone, and welcome to another episode of Learn With Jason. Today, on the show, we're going to be learning about DevTools, how they make us more productive and to teach us about that is going to be Elvis. Elvis, how you doing?

ELVIS KAHORO: Doing great. I actually woke up in the middle of the night because I was excited about this. I literally woke up at 2:30 and it finally wore off around 5:00.

JASON LENGSTORF: I get it, man. If I have a thing I'm excited about, I'll wake up and I'm like, no, no, this is when you need to sleep.

ELVIS KAHORO: I took some notes and it helped me go back to sleep.

JASON LENGSTORF: Nice, nice. We're talking, today, about a lot of things that are really near and dear to my heart. But first, I want to talk about you. Can you give us a background on who you are, what you're into?

ELVIS KAHORO: I'm Elvis. I work as a developer experience engineer, a developer advocate and in college, I worked as a software engineer. I care a lot about developer experience, which can mean different things to different people. But this space� at least regards to company and product, I really like working in DevTool, PLG, yeah, definitely PLG are the most fun.

JASON LENGSTORF: For sure. So, so let's talk a little bit about, like, devtooling here. PLG is productled growth, for people who don't know that. The idea behind PLG is that you're not a company that's driven by sales. You're a company that's driven by organic product adoption because the product is so good, people want to use it?

ELVIS KAHORO: Yeah, definitely. And I think [Indiscernible] you can go to a VP and be like, there are already 70 people using our product in the company. If you sign, like, a deal, you unlock team stuff and enterprise things that help them collaborate and have a symbiotic valueadd.

JASON LENGSTORF: We've seen a lot of products like this. I think the way that most of us use Figma, the way most of us use Slack or Discord. The team was already on it, if we formalize it, we get extra benefits so you get the company Figma amount or the company Slack.

ELVIS KAHORO: And volume discount, too.

JASON LENGSTORF: So we're working in DevTools. When we say "DevTool," it is tools that developers use to do their jobs.

ELVIS KAHORO: Soft development lifecycle.

JASON LENGSTORF: This could be anything from my code editor, to GitHub, maybe something like my terminal. Any other categories, here, that I'm missing?

ELVIS KAHORO: Yeah, like, I think a lot about infra, infra tools to help you test, [Indiscernible] the ergonomics there are so nice, they're kind of like meeting developers where they are, which is why it's, like, superpopular and every startup has a site that looks like their website.

JASON LENGSTORF: Every site looks like the Linear site. I got asked to build a demo, like a SaaS app. I didn't look at the Linear code, but I built a copy of the Linear. [Laughter].

ELVIS KAHORO: There's a website that tracks web pages that looks like Linear. There's 100 pages on there. [Laughter].

JASON LENGSTORF: That's really funny. So, the other big question that I have is that as somebody who loves Devtooling� I love tools, in general, I love to learn new things and play with new stuff. The sort of downside to tooling is that there's so much of it. And, there's so many things that I could be trying and I may be� if I switch to Vim, I would be more productive or faster. Maybe if I switched to VS Code or Copilot, I'd be productive. There's this vicious cycle of I'm never actually working because I'm optimizing my Devtooling environment. How do you manager this? How often do you find yourself adopting new tools?

ELVIS KAHORO: I try to timebox it. Usually I'm not trying a tool that isn't directly related to my� if I'm trying a tool that my teammate's not going to use with me, then I try to only test those things over a weekend, not over the work hours. So that's kind of, like, my way of isolating them into certain periods of time, which is pretty helpful because I can also batch tools. I might find four or five tools in a week, instead of going down a rabbit hole, if I put those on a Saturday.

JASON LENGSTORF: That is productive. I refuse to try anything new until people have been talking about it so long that I know it's not going to go away. [Laughter].

ELVIS KAHORO: Yeah. [Laughter]. Yeah. Yeah. Especially with startups because they get changed for the pricing model and it's no longer accessible to you.

JASON LENGSTORF: Sometimes, it's we love a new tool, as a community, but they don't stick. I spend a lot of time onboarding to something new and I find out that nobody's still there. The benefit I thought I was going to get is gone. It's like the social media thing, too. I usually join the social media network to get my username but I don't use it until I see people are there.
So, okay, let's talk a little bit about the specific tools we want to cover today. We were going to do a showcase, some of your favorite tools. You want to give the high level on each one?

ELVIS KAHORO: Yeah, I'll give the high level. I'll add, I started 900 projects so, like, if anyone's interested in learning about more tools, I kind of� GitHub Stars, you can make lists so I tried to categorize them. I have a Python list with 100 projects and a CLI thing. If people are looking for new tools, my Star page. I'm working on an app, I'm trying to make this a dashboard where I can do vector search on the READMEs and find the projects I've starred by describing them because I just don't remember the name. They'll have some, like, threeletter name. I'm not going to remember this tool name, but I can describe what the tool does. So I'm working on an app.

JASON LENGSTORF: Yeah, yeah, yeah. That makes sense. I actually had no idea you could make lists on GitHub, so today I learned...

ELVIS KAHORO: Yeah, in terms of the tools I wanted to talk about, I wanted to demo Warp and Graphite and then Reflex, if we have time for it.
And then, I wanted to give a shoutout to Chalk. Chalk.ai, because I'm really excited about things they're doing.

JASON LENGSTORF: Nice. Very, very cool. All right. So let's� I guess, where� where's the right place to start? I guess the right place is to start is open up a terminal and start rolling. So why don't we jump into this view, here, I'm going to put up this banner and I'm going to put up this banner and I'm going to talk a little bit� I dropped this link for everyone in the chat, if you were unfamiliar with lists in GitHub. We're talking to Elvis today so I'm going to drop a link here.
Then, these are a few of the tools you were going to talk about. So, this is Warp. This is Graphite. You said, let's see, here's Reflex. And then you mentioned Chalk. And is it Chalk.ai?

ELVIS KAHORO: Yeah. Yeah. Can we start with Chalk since I won't be showing it, I'll just be talking about it?

JASON LENGSTORF: Yeah, let's talk about it.

ELVIS KAHORO: It's for machine learning. For people that are working in ML, the quickest� the quickest explanation is that it's like a feature store, that's featurepacked. I can unpack the words, realtime, platform, ML. Chalk is a data platform that lets you deploy and build ML models and ML infra. And so if you scroll down a little bit, like, put the feature pipelines, so, the� like, the way you start it, you can build, let's say, like, a model that has a bunch of different� I think of features as datapoints. You're trying to make a decision, typically this looks like� let's say you have some kind of financial transaction and you're trying to determine if it's fraud. You want to look at different factors. Chalk, they're trying to do this for realtime applications so they have a bunch of optimizations so you can serve responses back with superlow latencies and so the three main benefits are scale, so, like, they have� they're kind of like one of the biggest users of Google's Kubernetes engine. They scale really well, you don't have to deploy it yourself. The second thing is pretty cool is that I think, like, 25% of all transactions are running� in North America, are running through Chalk, which is crazy. The main benefit is developer experience. You can define all your models in Python code and the cool thing is that they all got modeled and cached and they're, like, temporally consistent. It makes working with models really easy. And the nice thing is, it is Python, but it's also fast so there's a question of, how is it fast? I was thinking about it recently. Python is kind of just, for them, an interface and so if you look at this, it's all declarative so you're writing Python, but it eventually gets converted into C++ and Rust. I just really love the tool.
If I could access the tool earlier, I would have given a demo of this.

JASON LENGSTORF: Before we talk about Warp, I want to do one shoutout. This episode, like every episode, is being livecaptioned. We've got Vanessa here with us. Thank you so much, Vanessa. That is made possible through our sponsor, Tuple. It is great for pair programming, which we are going to show, right now, as I jump into� here's Elvis' screen.
Let me know, in the chat, if you want that bigger.
Now we're looking at Warp, that's warp.dev. If I want to get into Warp, what's the first thing I should do? And also, the first thing I'm noticing is this is already interesting because, why are we down here? [Laughter].

ELVIS KAHORO: I guess Warp is a terminal. So, it's like an app that you would download, like any other app. And you kind of want to use it as a replacement for your builtin Mac terminal. There are iTerm, [Indiscernible] Hyper. But in terms of why the input is at the bottom, you can actually move it around. You can move it to the top. You can move it to the bottom. I actually just prefer to have it at the bottom, that's why it's not moving whenever I'm running it, that way, it's in a consistent spot. I get trained to look at a spot when you put in the command you put.
There's a command [Indiscernible]. If I type "top," I can start input at the top and move it to the top.

JASON LENGSTORF: Okay.

ELVIS KAHORO: That's just a preference thing.

JASON LENGSTORF: The command pallet is interesting because as far as I know, I've never seen that in a terminal before.

ELVIS KAHORO: Warp feels closer to using an IDE.

JASON LENGSTORF: Interesting, yeah.

ELVIS KAHORO: Developer experience is trying to provide.

JASON LENGSTORF: Let's talk about how that actually works. When I use my terminal, I'm running commands I have memorized. Every time I have to open my�.zshell, I'm nervous I'm going to break my whole computer, which I have done several times. We've all seen how unpredictable my IDE is because I keep doing weird stuff to it.
As we're working in this system, what are some extra things that we can do? What's the workflow in Warp?

ELVIS KAHORO: There's hundreds of small things, but three or four big things that are game changers. I guess the first thing to show is...one, there's multiline. So, I guess, so this is [Indiscernible] and the nice thing about Warp is it is native so the Warp team built a native editor. When you decouple your input from your shell, right� so, I guess, even the higher level is the shell and the terminal are two different things but what's happened is, they've been kind of strongly, tightly coupled and so typically with a regular terminal, you're kind of using it as a screen that the shell just, like, sends characters to. Right. And so what happens is you'll type into a terminal, it'll send characters over to your shell. The shell will send you info back and take that input, parse it, right, give it to your OS. Do some computation and they come back and display more characters.
And so, a lot of people end up� especially folks who just came out of CS school, they don't realize the terminal and the shell are actually moving at two different layers. The shell is GUI. The key thing to learn about Warp is, like, oh, what if we only use the shell to run commands and then everything else, we're going to stop relying on the shell for and move it into the terminal layer, which unlocks mouse interactions, or having a command pallet because now you're not as a [Indiscernible] level. So, it opens a bunch of doors to innovate. In the case of this text editor, right, this text editor is sitting at it terminal level. These characters have syntax highlighting. It's the terminal doing that, not your shell. The beautiful thing about this, if I hover over this, I can see what the command is, right, and that's being provided by the terminal, not the shell. Right. If I add flags�

JASON LENGSTORF: Oh, my god, autocomplete for flags, with context. Holy shit.

ELVIS KAHORO: Yeah, with context. I can see my branches. I can do Main or whatever and use my mouse. I can delete this. I can undo, redo. I can also do, like, multicursor, right. Yeah. So that's the first thing is, like, improving the text editor.

JASON LENGSTORF: You did multicursor in your terminal? Can you do that again?

ELVIS KAHORO: There's a feature where I can� let's see...there's even a feature where I can write a command and send it out to all my panes. So, like, if you're SSHing into a bunch of machines, it can be broadcasted.

JASON LENGSTORF: That's slick. That's extremely slick. So, I feel like you came out strong out of the gate here. I feel like we're barely scratching the surface.

ELVIS KAHORO: I guess the next thing to show you is you can change your prompt, right. And so, like, for example, I typically use Starfish, which is, like, a crossshell prompt that� [Indiscernible] Rust. If you're on Linux, you can just install that same prompt and have it on all of your machines.

JASON LENGSTORF: Okay.

ELVIS KAHORO: It gives you a lot of context. I guess the thing to show, here, is, like, this is a prompt provided by my shell. Shell is giving me back characters. My input is attached to this prompt, right. But then Warp also has a native prompt. So this isn't running as a shell process, but a terminal process. The cool thing about that is that these� these� the different sections of my prompt are also clickable and interactable. I can copy my "get" branch by hovering over my prompt. Eventually, you can have an app store for your prompts and have a Spotify plugin and all of these things can be, like, running asynchronously. You can make a market where people are sharing prompts and things like that. These are things you enable by moving things out of the shell and into the GUI layer.

JASON LENGSTORF: That's really cool.

ELVIS KAHORO: I guess the next thing to show is...whenever I do run a command, Warp makes a block for you. I can scroll, up and down, previous blocks. This block is 10, 000 lines. So instead of me scrolling forever, I can actually jump to the bottom of it. Now that it's its own primitive, I can take actions on it.

JASON LENGSTORF: Just the ability to copy it. I can't tell you how many times I get, like, a really long error stack trace and I need to report the bug and so I'm like, copying and scrolling up in my editor, hoping I didn't miss the previous prompt and doublecopy. That� this� this, alone, feels like it's the price of admission.
Whoa, what's happening?

ELVIS KAHORO: I can rightclick them and take actions. I can copy the whole output. I can copy just the command. I can share a block and make a link to it. So I can send this to you in Google Chrome and you can open it and see what�

JASON LENGSTORF: Will you actually� will you just share that with me, real quick? I want to see how this works.

ELVIS KAHORO: This is what it looks like.

JASON LENGSTORF: That's incredible.

ELVIS KAHORO: Totally. There's another thing you can share, that's much cooler. Yeah, this is superhelpful if you're debugging. You're not taking a screenshot and putting it in Slack. People can see this.

JASON LENGSTORF: Yeah, QA engineers rejoice, indeed. Like, holy crap.

ELVIS KAHORO: Another example is I can click this block and then a second block and search in just these two blocks. You can add� you can select multiple blocks, search in them. I can bookmark them. If I've written a bunch of commands after, I can easily jump to a block that I've bookmarked [Indiscernible]. The last thing to show you, for blocks, is I can even filter the block. So...if I type, for example, "4701," you can grep every line on the block and only show the things that match your regular expression and the reason that this is cool goes back to the concept of, like, having separation between your GUI and your shell. Since we're slicing just the view of your data, two things happen. One, you can filter information as it's still outputting. Right. So I can have a process that's, like, showing logs on a server continuously and then I can filter them without quitting that process and feed them into grep.
If I change this, if I change this to 470�

JASON LENGSTORF: If I've tailed a log, can I do the filtering live?

ELVIS KAHORO: Yeah.

JASON LENGSTORF: Duuuude! Oh, my god. Okay. All right. So, I'm not going to lie, I must have tried to Warp when it was way too new because I don't remember any of this but it was years ago. Now, I'm feeling like I made a huge mistake in not paying attention.

ELVIS KAHORO: As soon as I saw this, I was like, wow, I'm obsessed. It was one of those "I couldn't sleep" moments. I was opening up feature requests on GitHub. As soon as you understand that, oh, you're doing things at the GUI, yeah, it's like, wow, the possibilities are endless and being able to work on the team� they're like, oh, I which the terminal did this and over the weekend, they build a prototype. That's a developer's dream.

JASON LENGSTORF: There's a great question in the chat. Anthony� what's up, Anthony� is it possible to control permissions on the blocks you share?

ELVIS KAHORO: Not yet. You can delete them after you've shared them, if you want to take them down. But I think eventually, that's an enterprise play, being able to have them restricted by domain.

JASON LENGSTORF: So if it's something that's private right now, I would copy and paste that in your private chat. If you open up that share block, there was a button that says "redact secrets." That's pretty dope because it'll pull out things� the important private bits, that's a whole thing that� you just don't think about when you're� you know, when you're copypasting terminal output, sometimes you remember that you've got a console log somewhere that checks whether the environment variable was showing up. Having this button saying, hey, automatically get rid of these things that shouldn't be there. That's huge.

You can add your regular expressions and expand how you find your secrets and stuff.

JASON LENGSTORF: Yeahhh. This is so cool. All right.

ELVIS KAHORO: Next to thing to show you, in Ctrl+ r, you can search through your history and so if you press Ctrl+ r in Warp, you can search through your history and features and workflows and things. If I type, like, "get� this is fuzzy search. The nice thing is there's a SQLite where we can keep metadata. We'll keep� oh, this is a folder or path you were on when you ran that command. This is how long it took to finish, this is when you ran it and eventually it's like, you can build this analytics layer where you can filter your history and then, like, jump to a previous session.
In the future, like, there's a [Indiscernible] a staff engineer fixes a sev, hopefully you can expose it to save that as a session and use that to train other people and do retros, postpartums, things like that.
There is also a feature called workflows. They are commands you might run often or you run infrequently, but they're important. You don't want to get stuck trying to remember what combination of tools were in that command. It's much better to be able to give that command a description, based on what it does and then you can save them in your terminal and quickly find them and the cool thing is that when you do save them, you can add descriptions to each parameter that you're supposed to change and then I can essentially, like� yeah. So, you end up opening up this pallet and then you have a different [Indiscernible] for different tools, right. I usually use Grep as an example. When I click this, I can shifttab to switch between parameters. I can go to file path, press Tab again. Pick a file. Shift+Tab again. If I look at the diff, right, I just ran this command, replaced it with new text. And the cool thing is that you can save these commands personally, but also at the team level.
Warp has a team concept where there are things you can save for your team or just for yourself.

JASON LENGSTORF: Got it. That's realty interesting, too. When I was at Netlify, for example, we had a lot of things we would do, where people needed to query our big customer dataset to understand what had happened with xyz log or we needed to dig through customer activity to figure out if anybody was using some feature. So they had a big, shared document with copypasteable commands. Nose snippets, a lot of times, were somebody did a thing and they copypasted it in and maybe they added a title of what it is. A lot of times they didn't include that, they were like, this is how you get x thing. If you wanted to make a new query, you had to find the person who wrote that query and asked them how it worked. This is an immediate powerup for teams who are doing a lot of commandline queries.

SREs [Away from mic].

JASON LENGSTORF: That's a really nice feature.

ELVIS KAHORO: You reduce drift, right. I might copy this from our shared Google Doc and I make changes. I'm not going to go back to that Google Doc. I close that tab, that tab is gone. It's too much work. [Laughter].

JASON LENGSTORF: True. So how does it work if I do want to update it? If I've got a grep command I've put in the library and I make a change?

ELVIS KAHORO: Yeah, so let's say� I'll just copy and paste this. Right. This is how you save it. Right. I can save as workflow and then I can actually do autofill and then autofill is, like, I can give this to AI and have AI try to determine what things are worth changing and then it'll kind of make my primers for me. Yeah, then I can, like� let's say I create this, right? Typically [Away from mic] so if I go to my little Warp drive thing, right...where did I save it at?

JASON LENGSTORF: I think it might not have finished saving.

ELVIS KAHORO: Oh, really? If I open it back up [Away from mic] yeah, so typically the screen will look like this again and then I can just click� instead of� it'll be "update."

JASON LENGSTORF: Got it. Very cool. Very, very cool.

ELVIS KAHORO: Yeah, so those are workflows.
And then the next thing to show you is Notebooks. So, Notebooks, they're similar to Jupyter Notebooks. Instead of these being Python code blocks, these are shell code blocks. This is support for Java, JSON, YAML. These are runnable so I click through and run these commands, right. So now you can make a bunch of notebooks for different tasks. You clone a new project, internally, and then you have a notebook� this is how we deploy our database. So, I can add� I can add regular Markdown, right. So I can give descriptions to every one of these blocks. In this step, do that, do this. You can move away from having just, like, static GitHub READMEs or also Confluence Docs.

JASON LENGSTORF: Does this have, like, sort of, like, a reverse� a graceful derogation? If I make a notebook on how to deploy it, does it gracefully degrade into a README that somebody can find on GitHub or only Warp users can see the notebook?

ELVIS KAHORO: Only Warp users can see this but you can convert it to Markdown. With the workflows, workflows, you can define them as YAML and then you can have them set up so that Warp automatically pulls up any workflows that are edited in your repository. You can have a repo and a�.warp folder and have workflows there, that way, when you switch to that directory, a bunch are available because they're mapped to that particular project.

JASON LENGSTORF: I understand. Okay. All right. That seems cool.

ELVIS KAHORO: Yeah, notebooks are tight. Notebooks are tight.
And then, yeah, let's see...so, another thing to share is that Warp has a lot of window management. Right. So I can make multiple panes. I can drag panes around. Rearrange them. I can also, like, maximize the pane; minimize it.

JASON LENGSTORF: As a developer, I do seek to maximize pain often. [Laughter].

ELVIS KAHORO: It definitely was a lot of [Indiscernible] internally about when we were doing pane management, the pane management project. [Laughter]. And then, a couple other features� I guess the next� let me actually see if I have this repo. I don't have this repo. But there's also� there's a lot of AI features built in and so I can...what's a good project? So I can use AI to be like, "write me a command that counts."

JASON LENGSTORF: So something just happened when you moved into this mode. What did you do to make this happen?

ELVIS KAHORO: I pressed Command+i, it switches to Agent Mode. You can essentially start talking to, like� I guess this is talking to Claude. It's fetched to AI and you can essentially go back and forth. The cool thing is now I can actually run this command and then the idea is that the output of, like, me using these AI commands is a block in and of itself so I can have this be not only command history, but chat history and I can switch back and forth. That way, I can stay in the flow when working with AI versus switching to a different window.

JASON LENGSTORF: That is really interesting because I do find that something that keeps me from using the chat� like, the AI chat agents, is I feel like I'm jumping out of my workflow to open the chat flow and I forget it's there and which monitor it was on so being able to keep it in the context of what I'm doing is pretty interesting.

ELVIS KAHORO: You can open a pane and have chat on this pane. OS. And then, "chatting with AI." You can minimize it.

JASON LENGSTORF: You can have a pane that is minimized.

ELVIS KAHORO: It's hidden.

JASON LENGSTORF: That's cool. I do that all the time, where I've got a second terminal that's running some background process and I wish I could make it disappear but I end up having a second terminal that's tucked off somewhere or I have layered terminals. That is also a nice, nice feature to have.

ELVIS KAHORO: Yeah. Warp supports backgrounding a process. It's not something I do much.

JASON LENGSTORF: I've done the backgrounding and foregrounding before. And I always forget how it works. I know you type "fg" to bring it back. I always forget it's there to bring it back and shut it down. [Laughter].

ELVIS KAHORO: Yeah. Yeah. So I just do things with panes, typically.
Um...okay. There's a couple more things. Oh, another cool thing is, like, if I am using the AI mode, I can actually� I can click a block and have a block as context. I can click this and this automatically gets added as context. If this, for example, errored, I can be like, "help me debug this," and it knows what this is because I've attached this as context. So that's, like, really ergonomic.

JASON LENGSTORF: This is one of those things where� I think this is why people get excited about the IDE editors and stuff, where you can click on a line of code or highlight a block of code and say, "explain this to me." That feels so much nicer than copypasting something out in a chat box and waiting for the bot and copying it back out. When you say, "help me debug this," maybe we try this on one of the airs you got earlier and see� because my assumption is what will end up happening is it'll say, this is what I think is wrong. Do you want me to run this command to fix it? Maybe we misspell a Git command or something.

ELVIS KAHORO: Like that. So, one will try to fix it for you. GT is Graphite, that's why� I use Graphite more than I use Git, actually, so that's why it's giving me back Graphite. It will automatically try to suggest you a fix. If I Command+i, it'll help me debug.
On my old laptop, I had a better setup. I got it on Cyber Monday.

JASON LENGSTORF: You went to type "Git status," it gives you the block to run. That's� and I think this is� like, this is what I want AI to do. Like, I don't necessarily want to have, like, a second window or something that's sort of like always watching or listening. If I hit something and I'm like, wait, I thought that was right� and people see me do this all the time on the show. What's the thing I'm missing? If I could rightclick it and say, what's wrong and the thing's like, looks like you did this. I want it to be an unblocker.

ELVIS KAHORO: [Away from mic] there's also a notification feature so if you have a command running� let's say I do a "sleep 2," then I hide Warp� I don't know if my permissions are set up for this. At the Sleep 2, I'll get a notification up here, this command finished running.

JASON LENGSTORF: That's dope.

ELVIS KAHORO: I think I'm on Do Not Disturb, because of the stream.

JASON LENGSTORF: Yeah, that would track. [Laughter].

ELVIS KAHORO: Those are some of the main features. The last one I wanted to show you is� I think one of the benefits of Warp is that it's written in Rust and the team cares a lot about performance. Did I hit a limit? Oohhh, no. I hit a limit. You can actually share your Warp session.

JASON LENGSTORF: Oh, okay.

ELVIS KAHORO: You can essentially run a headless version of Warp through WebAssembly and I'll have Warp be halfscreen here, halfscreen here and then I can have� I'll literally be looking at my same Warp session on this right side and then I can suggest commands to run on this one or I can scroll through the output and it's really nice for pair programming because instead of, like, Zoom, where I can only see what the person is showing me, having the browser version of Warp, I can scroll through the output and say, try running this and send a push and they can be like, accept or whatever, when they run that command, which is really good for pairing.
I guess I hit the limit because I'm not in the Warp [Away from mic].

JASON LENGSTORF: I got it.

ELVIS KAHORO: Those are the main things I wanted to show you.

JASON LENGSTORF: That's great. I think there are a few things that just, like, make this feel� I got to get it. I think a lot of the shared features, the collaborative features, you know, given that I don't do a ton of code collaboration anymore, I can see how I would have used them in previous jobs. Honestly, even without those, the blocks, being able to copy the output with a button as opposed to having to scroll through my giant block of whatever, being able to skip and forth to figure out where the output was as opposed to having to scroll and look for the commandline prompt. Those are the things of things that I just� you don't realize how much time that eats until you're not doing that and watching how quickly you were toggling between blocks, I had that sinking feeling of, god, I've spent a lot of time just dealing with the terminal output.

ELVIS KAHORO: Yeah, literally just that. It's also, like, for me, you� once you get used to it, going back to a regular terminal is so hard and I've literally almost smashed the keyboard. [Laughter]. Because I'm like, pressing Tab and I'm not getting my suggestions and literally almost smashing keyboards. Especially because you build your muscle memory with Neo Vim or Vim, it's automatic and your brain is reacting to what you want to do and it's not working and you're frustrated.

JASON LENGSTORF: And the interesting thing is for DevTools, it's giving us the ability to offload the unimportant parts. Memorizing a Git command is not an important part of the job. It's a thing we have to do to get our work done. It's that I know I need to Rebase. And so if the terminal can sort of take the, remember this specific flag, remember what order things go in, if it can remove that Google search or free up that space in my brain where I go, Git, Rebase, I can just continue working instead of pausing to think about how the tool works and that's where I think Devtooling really gets� what's why we love TypeScript, for all the pain that TypeScript causes, knowing that you immediately get an underline if you try to use something that doesn't exist, getting a helpful suggestion or autocomplete, those benefits are so valuable that it's worth the switching cost. I think that's what I'm seeing in Warp is a similar kind of� it's worth the switching cost because you're going to save so much time.

ELVIS KAHORO: Your goal is to free up cognitive memory so you can stay in flow state and with the TypeScript and, like, type languages, right, I think if you're early� early engineer, it's very tempting to be like, oh, running TypeScript, this is my velocity. That may be true for the first 1,000 lines of code but, like, in the long run, having guarantees around what things are front loads so much headache, you can find things way earlier. I want to find things before my app is send to GitHub and builds. Not when a user gets [Indiscernible] and now I'm going through a stack trace trying to figure out, why did this break? Huge fan of type languages and the guarantees they give us.

JASON LENGSTORF: We talked about Warp, Warp's dope. We're about halfway through the show. You mentioned Graphite, let's look at Graphite. I've never hurt of Graphite before, so you're going to start from zero here.

ELVIS KAHORO: I think what Graphite was solving was being able to manage stacked diffs reasonably.

JASON LENGSTORF: I do remember Graphite, but I've never used it.

ELVIS KAHORO: Cool, cool, yeah. The goal is I have Main here, this is my Main branch and then if I'm working on a feature or a new function, I want to be able to, like, split up my work into� into� kind of like blocks, but I want to split them up into unified logic so it's like I'm making changes�

JASON LENGSTORF: Change per branch.

ELVIS KAHORO: Yeah. Some people have multiple changes per branch. If you can have one change per branch, one, the code is easier to review and, two, Graphite allows you to Rebase everything that comes after that branch if I make changes.

JASON LENGSTORF: So this is actually� you're addressing, like, a core pain point that I think prevents people from doing one change per branch because I think we like the idea of one change per branch but when we have 50 branches open and it takes a day or so for people to review because we're all busy and everybody has a bunch of PRs. The pain of merging yesterday to today, we end up with super branches, it's harder to review, it's harder to merge. You can't review 5,000 lines of code well if your job is to write code. So if we take the pain away of having lots of branches and being able to merge in the upstream changes, that suddenly removes the blocker for me doing smaller PRs. Being able to get quality feedback, somebody can quickly understand what I'm doing and give me a reasonable, yes, this is good, go ahead. Now I'm significantly less blocked.

ELVIS KAHORO: Yes. A couple things there� and it's like, if you can make managing the Rebases for this easy and managing your branches easier, developers don't get frozen in time waiting for review because they're scared they'll get feedback and they'll have to fight Git. So Graphite solves a bunch of this.

JASON LENGSTORF: I just had a flashback of when I was working at IBM. We would hit a point where we would stop work because we knew if we kept going, it was going to create so much pain that it might delay the launch so we would kind of wait for the batch of work we'd done to get merged and then we'd pull a new copy of the Main branch and the development branch so we could work again.

ELVIS KAHORO: Precisely. I guess I could give you a demo real quick. I added one line of code called "test." I can look at the diff here and see. Graphite has a bunch of commands for moving up and down my branch list. So if I do, like� one thing, so this is like, superoptimized to me so it's not clear what it is I'm doing. This is my Git config. [Laughter]. I have hundreds of aliases. What I'm doing is� for a lot of them, for example, this cherrypick command, I type "get cp," I'm feeding it through Git Aliases. I don't remember the Graphite commands because I've been using aliases for so long. I can't tell you what they are because I just type and it just does things. [Laughter].

JASON LENGSTORF: All right. [Laughter].

ELVIS KAHORO: I have this change. Let's say I create a branch and call this "Elvis test." Save this, right. So, this is creating a new branch. When I look at the tree, both of these branches have this one as a parent. Right. So I can do, like, Graphite essentially down, branch down and go down a branch. Now I'm at this parent branch. If I do back up, it'll ask me which one I want to jump to because there's two options. Right.
I guess another quick example, I can do another� I don't know [Away from mic] so I'll do� actually, let's call it "test 2." [Away from mic] down again and then, do one here...see, I do "test 3." And then jump to Main. I look at this tree again, right, this is my next branch. These are my children branches and things. I can type a Graphite� I don't know, it might be top, that's what I call it. It'll go through and look at all of the lowest nodes in my tree and ask me which one I want to jump to. If I had a bunch of different forks, it's going to essentially go to the bottom of them and then I can jump to them, which is really helpful.
In this case, let's go to "test" and then they have some other commands that are pretty helpful. One of them is� let's see...I guess it's more interesting, I'll make this longer. So, let me open this up again. I want to add another test. Let's see..."test 4." They have another command for reordering your branches. I can, like, [Indiscernible] around and Graphite will automatically go through and restack them and reorder them in the way that I want and if I merge conflicts, it'll say I have a merge conflict. I can continue my Rebase. So two commands. I can reorder literally four or five branches and Graphite will go through and fix them.
Let me go to this one and fix this one. Let's do [Away from mic] change. [Away from mic] Rebase. And then at the end of this, right, you can see that now this is fixed, based on how I want it. So the helpful thing about this is if I submit a PR for this branch, here, and get a review, once I get my review back and make changes, I can jump to this branch and be like, restack all of the children branches and then automatically resolve the Rebase and it'll automatically restack everything that's a descendant of those branches and the cool thing is the Graphite team has been really disciplined about only using Git Primitives to do all this magic and so you can do some of these things using Git, it would take 30 minutes to do.

JASON LENGSTORF: Everything that's being done is, like, reflected in the Git history, but Graphite is providing, like, a shortcut to do really complicated Git stuff.

ELVIS KAHORO: Supercomplicated stuff. For example, if I just rename a variable, right, I shouldn't have to Rebase every single branch after that. Graphite can go through and fix that.

JASON LENGSTORF: And so, to� I guess, to repeat this back because a lot� a lot has happened. So, if I'm working, right, and then I'm going to actually draw on the screen while I talk about this. We've got our Main branch here and as time goes on, my teammate pulls a branch and it ends up over here and a commit happens here and then somebody pulls a branch and ends up over here and then another commit happens here and time continues. So what we would typically have to do is any changes here would have to then be brought in here. We have to make sure that these are synced up and then we have to make sure these are synced up and then we have to make sure that these are synced up and finally, we have to bring this back into the Main branch, where it becomes a commit and then the same thing needs to happen here, where maybe this one works, but maybe this one has to go back to all of these before it can come in and finally become the main part of the branch, right.
So all of these different changes, making sure that whatever's happened at each commit in the process, what Graphite is doing is instead of making me do, let's see, one, two, three, four operations, it can sort of automate, grab that, grab that, grab that, grab this, if there's no conflicts, it does it. If there's a conflict, it shows me the conflict and says, what do you want to do? And I choose which thing I want to do and I say "go" and it gets me to the end.

ELVIS KAHORO: If there's another conflict, it'll stop there. And then, boom, you've moved that branch six places. 10 seconds. Yeah.

JASON LENGSTORF: So this, to me, feels like one of those things that, it doesn't� the way that a lot of us have chosen to solve this is that we will do things like forced merges. We will do things like big, old squash commits and stuff like that and the force commit is probably a bad idea because you have a chance of blowing away your teammates work. Swash rebase, merge commits, whatever, we can fight about those all day. The nice thing about this is as a Rebase, you get to retain, like, everybody's work so you� you know, on a linebyline basis what each person did, when you squash or you mergecommit, sometimes you lose some of that branch context of who did what it all gets merged into one branch and dropped into the Main. Rebases can be complicated and painful because if you don't know the command, it's a lot. So this feels like a really nice way, when you're working on teams that are moving fast to keep your velocity without sacrificing the trail, the bread crumbs of what happened, causing people to make decisions, like holding off until the next Main branch gets pulled.

ELVIS KAHORO: Telling a story. Telling a story with my PRs so somebody can follow the logic. The cool thing with them, they have blog posts. They're in the position to see that other people can't because they're like, hey, the best PRs, with regards to review and review time, are, on average, 50 lines of change. They can introspect from an analytics point of view.
There's a couple more commands I want you to see though.

JASON LENGSTORF: Yeah, yeah, please.

ELVIS KAHORO: You can stack on to. I'm on this Test 2 branch here. So, I can type this and then I can choose where I want to move this branch to and so let's say I move it to Test.

JASON LENGSTORF: I'm sorry, you're literally changes its parent? So it's going to unRebase the current parent and reRebase it? I think I did that once and it took me a whole day. [Laughter].

ELVIS KAHORO: A whole day. This is literally five seconds.

JASON LENGSTORF: That's incredible. All right. All right. I'm seeing the value here. This is the sort of thing that� especially if I've working on a feature branch, I will get myself in a mess with Git. I'll be working on something and pull something. I notice a problem and fix that problem and go, oh, crap, that needs to be its own thing so I'll create a new branch and commit that change and then, wait, I'm not actually going to ship this feature but I want this fix to go back in. What I would typically do� and it sucks� copy that code, check out Main, create a new branch, open a PR because the thought of trying to, like, move my branch of a branch back into the Main, I'm like, I'm not doing that. I would manually copypaste. This saves me a lot of heartache because I can say, move it over here.

ELVIS KAHORO: I just moved Test 3 on top of Test 2 and moved to Test 4. I can also move Test 4 to be on my ETL branch. There might be one more.
Now, we have a vertical line, right, these are all on the same path now. And so the cool thing now, as well, is� so if I jump to the top of this, I can actually fold this branch into the previous one. Right. So if I do this...it's going to combine the two so now if I look at it, that commit, or that branch, is also on this branch.

JASON LENGSTORF: Yoooooo.

ELVIS KAHORO: Both of these commits are on the same branch and if I want, I can actually squash these on the CLI and it'll move those commits into one. If I check out this commit, right now, these are two. They've both been merged into one branch.

JASON LENGSTORF: Okay. This is probably where I would stop worrying about it because I feel like this is one of those games I've played, where I end up trying to make everything perfect, I'm going to have the cleanest Git history ever. Props to doing it. I found it turns into a perfectionism thing because I don't commit code because I'm trying to make it perfect.

ELVIS KAHORO: There's a checkpoint in terms of how you're thinking.

JASON LENGSTORF: I love this. I love this. This is fantastic. I think� and I also think it shows that when you're looking at DevTools, you have to find the ones that make you more productive. For me, I need the thing that lets me commit code in a way that's usable by other people that's as fast as possible but I can't worry about the specifics of the commits because I'll rabbithole on that forever to make it clean so somebody can read my commit history like a book.
If I make sure all my PRs are good, I can read my pull requests like a book, that, to me, is important. You have to find the layer that works for you. What I'm loving about this is this idea that I don't need to be ultra vigilant. If I need to move that branch later, I can and it doesn't cause me to lose, like, a half a day. That's huge.

ELVIS KAHORO: Yeah, superhuge. I have Commit for every one I have. At the very end, this is all going to be in the same PR. I'm just going to squash it into one. And another thing that you can do� I'll show you real quick. I want to fold these three branches into one branch and so I have three commits here. Right. I can actually also split them. I split them by the commit and be like, all right, so I want to keep these two commits on one branch and move this other one and then I can� this, this, this, that, something. And it'll actually do that. I split the two by the commits.

JASON LENGSTORF: Bro....

ELVIS KAHORO: I can look at, do I want to stage this particular thing, make it its own branch and things.

JASON LENGSTORF: Yo. That's huge. That's the other problem is when you accidentally commit 500 changes into one thing and you want to merge part of it. This commit is where I made the thing that needs to merge and the rest of the feature branch can wait. Boop, and you're done.

ELVIS KAHORO: I have also have a couple of Git commands that help me a lot. I'll show you one of them...so, I have this command, right here, for diffs. If I don't give a number, it'll give me the current diff. If I do D4, it'll show me four commits back and show me the whole thing. I'm using this tool called Dexa, which is a pager. It's a really good tool, it's called Delta. I'm using that as my Git pager. It gives me line numbers. It gives me the function that this falls under. That way, I can find it in my code. In Warp, if you have a file path, I can Command+click.

JASON LENGSTORF: Duuuudde.

ELVIS KAHORO: You can be supereffective.

JASON LENGSTORF: I want to make sure we share this with everybody because this feels like a super useful tool. So that one was called�

ELVIS KAHORO: Delta [Away from mic].

JASON LENGSTORF: Syntax highlighter pager. This one? That's incredible. That's a hell of a tool. I'm going to share Graphite again because I think I shared it earlier on and people didn't get a� wait, am I on the right thing?

ELVIS KAHORO: They do more than what I'm showing you. This is the entry point. I'll try to show you the other things they do that I use them for.

JASON LENGSTORF: Got it. And then, do you have your aliases up somewhere. That D command, for example, is one I want.

ELVIS KAHORO: If you go to GitHub and type my name, go to repositories. I have all my stuff there. It's all in Git Config. They're behind Git and Git is the gater.

JASON LENGSTORF: Dude, this is wild. This is the wildest aliases config I've ever seen. I'm going to throw this specific permalink for anybody that wants to use that exact command. If you go to the Learn With Jason Discord, it gets thrown in the ShowLinks channel. I'll throw the Discord up on the screen, as well.
But, yeah, this is� this is cool stuff. Like, extremely cool stuff.

ELVIS KAHORO: There's a couple more things I want to show you about Graphite.

JASON LENGSTORF: Yes, let me get back over to your screen...

ELVIS KAHORO: So, let's say this branch, right, the files� this is another good command, DL, which is just showing me the files that have been changed in that particular commit.

JASON LENGSTORF: My alias for that is "S." [Laughter].

ELVIS KAHORO: Are you running status?

JASON LENGSTORF: I have a specialized one that just shows me a list of files.

ELVIS KAHORO: DL, for me, is the files that were changed in this commit. Yeah. And so, another good thing about Graphite is, like, so, in this branch, right, these are the files that have been changed so I've changed this connection file. Right. Let's say I'm not on that branch, I'm on this top branch. And then� actually, let me [Away from mic] real quick...okay. This is on temp. Okay, these are both temp. We fold this, squash this. Okay. Cool. Okay. And then, I'm going to reset this and then I'm going to stash everything in this and then keep this and then� I'm just trying to set up a little demo real quick.

JASON LENGSTORF: Yeah, yeah, I gotcha. Somebody's going to have to watch this back at�.5x speed to see what's going on right now. [Laughter].

ELVIS KAHORO: I'm going to show you the next command that's pretty helpful. Let's say I make a change to this connection class. Let's say I add a timestamp or something� date/time is there, cool. So, I look at my diff, right. We added timestamp. Right. I can actually� Graphite has a command called Absorb, which is so sick. What it'll do is, it'll ask me� it'll ask me for the changes I want to stage, in this case, I want to stage this change and it'll go through my branches, figure out the appropriate branch for me to stage that change, stage that change, automatically restack everything that depends on it and keep me on the current branch.

JASON LENGSTORF: Okay. Let me repeat that back because I think my brain just melted. If I'm on Main and we've pulled a child of a child of a child�

ELVIS KAHORO: We're three branches down, we're here.

JASON LENGSTORF: When you say "absorb," it goes back to Main� or wherever the change would need to be added. It finds the spot. It puts that change in and then Rebases all child branches against that change.

ELVIS KAHORO: And keeps me on the same branch I'm on.

JASON LENGSTORF: Holy shit.

ELVIS KAHORO: And it'll do it for multiple files. It'll split them and put them where they both belong and put me back to where I am. Oh, there's a bug? Graphite, absorb. Fixing a bug is, like, trivial in terms of adding it.

JASON LENGSTORF: That's out of control. Dude, okay. All right. I'm� that one feels like� I'm learning how Graphite works now because that's worth the price of admission. The kind of stuff that just� I just don't deal with and I'd be like, it's fine, we'll get this change merged in eventually. [Laughter].

ELVIS KAHORO: Oh, Patrick's in the chat. Hi, Patrick. This is Strawberry GraphQL. I'm in your Discord.
There's a web console and you have a dashboard where you can submit PRs and things and you can submit PRs using Graphite so I use "Graphite submit" and "help." There's a bunch of things I can do here, right. If you submit with Graphite, kind of the things we talked about where somebody looks at the review and makes changes, Graphite will keep that intact.
My command is� let me go here. Submit with cli and use AI. So the cool thing about this one is� so let's say two branches down, I run this command, it'll jump to this next one and since I have the AI flag, it'll parse my PR, right, give me� suggest an AIdriven title and press Tab. If you look at the PR description, this is AIgenerated. Yeah, that's pretty good. I can publish that PR and it'll go to the next branch. It starts on the branch you trigger Submit from. It goes to the next branch and generate a PR title description for me.

JASON LENGSTORF: Oooohhhh, that's�

ELVIS KAHORO: I don't think I've written a PR description, from scratch, in, like, two years.

JASON LENGSTORF: What this is doing, just to repeat it back and make sure I understand. You're on� the "test this branch." You're saying, I want to merge into Main.

ELVIS KAHORO: But I have to submit.

JASON LENGSTORF: You're asking Graphite to build the chain of PRs.

ELVIS KAHORO: I can write the titles, description all from the cli so I'm not switching to a different tool.

JASON LENGSTORF: This is, like� man, I just can't� like, this is� this is truly hard stuff. [Laughter].

ELVIS KAHORO: This is a good description. This is a way better description than what I would write.

JASON LENGSTORF: Mine would be, "trust me, it's fine." [Laughter].

ELVIS KAHORO: It's going to publish these and give me a link to them so I can view them. I can view them in the Graphite cli and view them in Git. I have an alias that will automatically open that PR in GitHub. This is what it looks like in GitHub.

JASON LENGSTORF: Does it show the dependencies?

ELVIS KAHORO: You can see it here. It shows the tree and their UI. What I can do is, I've literally opened up 8 or 9PRs before. If I don't need someone to review them, I can jump to a particular PR and go here and be, like, Rebase and merge and Graphite has it merged to and they'll go through and Rebase all these PRs and it's five minutes later, I merged six PRs and they've been tested and checked and things.

JASON LENGSTORF: Holy crap. [Laughter]. Like, that's� that is out of control.

ELVIS KAHORO: Yeah, yeah. Supernice. [Away from mic].

JASON LENGSTORF: Okay. I understand why everybody was talking about this. This is� this is some really powerful stuff.

ELVIS KAHORO: Yeah [Away from mic] team is pretty awesome.

JASON LENGSTORF: We have, like, nine minutes left. I don't know if we're going to have time to cover Reflex. Did you want to cover anything else in Graphite or a highlevel on Reflex?

ELVIS KAHORO: I'll do a high level on Reflex.

JASON LENGSTORF: Okay.

ELVIS KAHORO: Let me go to the Reflex docs. So, Reflex is a Python web framework that lets you build fullstack apps all in Python. And, what they're doing is pretty incredible, to be honest. So typically, I think for a lot of projects, you have a FastAPI. Reflex has an extensive UI library. If you're building an app� especially if you're building an internal app or a prototyping app, it's a lot easier to build it in Reflex because you don't have to write a bunch of boilerplate because Reflex, being a full framework, will abstract away a bunch of those things, right. And so, the easiest example to show is I have this simple counter App where I can increment these buttons. When I click "increment," it goes up by one. The logic for all this is, like, 20 lines of code, maybe.
So, what you do is, you import Reflex and then what happens is you end up having a state and you end up having a frontend and so this is my frontend for this app, right here. And so�

JASON LENGSTORF: So, yeah, I see� I'm tracing. So, the H stack is like the document.

ELVIS KAHORO: Yeah, yeah, pretty much.

JASON LENGSTORF: We put in the elements and it looks like Reflex has the shorthand for the elements. I assume these are all type. As I open the button, it's going to give me autocomplete.

ELVIS KAHORO: The most beautiful thing is I can bind all of these elements to functions in my state, which is [Indiscernible] and so I can say, "on click," if someone clicks this button, I'm going to run this function decrement and this is going to change count, right. And then Reflex keeps track of everything that's binded to Count and will automatically update any components for you. And so, the actual display of this number 12 is this heading right here, right. I don't have to say, do this thing to change heading. I can say "change count" and everything that depends on Count automatically gets changed.

JASON LENGSTORF: This is bringing in the reactivity of JavaScript frameworks into Python, which like� for those of us who have been working in JavaScript for a long time, we forget when you're dealing with something like PHP with Python, we don't have that automatically reactivity most of the time so we have to do something like update the template, refresh the page. This is very nice.
I believe I remember you saying that this can also, like, ingest React components. If I have a design system or something, I can just throw it in?

ELVIS KAHORO: All of these components, like button� let me show you some of these components. Avatars, badges, forms, these are all React components that have been wrapped in.

JASON LENGSTORF: Okay. I got it.

ELVIS KAHORO: So these are React components. When you deploy your Reflex app, all of this frontend code gets converted to React and then all of this backend code gets turned into FAST API and it sends changes to your UI over the WebSocket and the onclicks get sent back to your backend and Reflex manages all the stitching the two together. If you look at their home page, one, all of this is in Python. They have a bunch of themes that you can, like, use out of the box. They also have a bunch of sample apps you can use. There's a really good LlamaIndex app, you can play around with some of these and look at the code for them and it's all Python so this is supergood for internal teams because a lot of people who are doing data engineering or data science, they come from an academic background and it's like, one, they don't know JavaScript. Two, why would they want to learn JavaScript, given that their core job is to do analytics, they still want to share results and things and build an internal app the team can use.

JASON LENGSTORF: I think that's the core value prop here. It's not necessarily� if you're a JavaScript dev, you should consider learning Python to write code in Reflex. If your day job is Python and you're doing� there's so much of the AI stuff is powered by Python these days. There was a stat at GitHub Universe that Python is the fastergrowing language on GitHub for 2024, due in no small part in the huge rise in AI popularity. So, if you are a Python engineer and most of what you're doing is machine learning or datasets before AI, Python was huge for� like you said, academic stuff, building out� doing math, doing machine learning, doing all these sorts of things that are very dataintensive. If you want to show your results, you have something here, being able to go to that Reflex showcase, I need to show a graph, let me copy this code and retool it to use my data, which I know how to do in Python and you get a nice, reactive, cool thing.

ELVIS KAHORO: Yeah, it's kind of incredible and the cool thing is that now, backend people can get the same kind of expression that frontend people have and now they can build things that people can interact with, right. If you look at some of the case studies that Reflex has made, what would happen is you would� I guess in the Fintech sector, they would prototype an idea and prove it out theoretically with Python or R and hand it off to another team to then spend like, four or five months building some sort of app that internally people have access to and it's like, now you can cut that from six months to one and a half months and enable the people who are doing the core MVPing the ability to do that.

JASON LENGSTORF: They can build their MVP app. That's huge. And, like, you know, one of the things that so important� we got to wrapup after this. The thing that's so cool about this is, like, internal tools almost never get funded, no matter how important we know they are, no matter how important we feel they are, the feeling of doing� let's just go back to this screen here. The feeling of doing this internal� these internal tools, companies won't fund it because customers don't see them, customers don't pay them so why would we allocate funds no matter how much we need to see dashboards or verify a thing.
So, yeah, really, really interesting to hand them tools that let them solve this problem without a lot of resources and without needing a ton of buyin or funding. That is�

ELVIS KAHORO: They can use any machine learning library they want. You're adding a frontend.

JASON LENGSTORF: That's really, really cool. Elvis, unfortunately, we're completely out of time. I'm going to do a quick shoutout so we can say, let me do another quick shoutout to Elvis. Go and connect there. And also, make sure that you give a little shoutout to our sponsor, Tuple. That's how I was drawing on the screen, doing the reactions and stuff. We also had Vanessa here, from White Coat Captioning, doing all the live captions. Thank you, Vanessa, for being here.
While you're looking on the Learn With Jason website, you should head on to the schedule and you can find the other shows that we've got coming up. We've got a great, great set of shows coming up. We're going to learn about Turso. I had to reschedule this one because I had a travel nightmare. We have Cory coming in, I'm superexcited about it.
So, set your calendars. This is going to be� with Cory, the last one for the year. That is next week. And, I think it's going to be a banger to send us into the holidays.
Also, stay tuned on the Learn With Jason YouTube because we have a new episode of Web Dev Challenge and Lete Heat. Make sure you're watching the Learn With Jason channel for that.
Elvis, thank you so much for being here. Any parting words for everyone?

ELVIS KAHORO: I don't know. I feel like it's� right now's the greatest time to be a developer because we have so many tools that help us be productive. I don't know. I feel like I use the holidays to code more because you have [Indiscernible] so happy coding, everyone, over the holidays. [Laughter].

JASON LENGSTORF: I love it. What a great note to end on. Thank you all, so much, for hanging out. I will see you next Tuesday, on the livestream. Take care, y'all.