0:06 Filling out with beats so sleek. Sebastian Seated guy, the geek. Runmeets has Hello, and welcome back to the Rawkode Academy. I'm your host, David Flanagan, known across the Internet as Rawkode. And today, we continue the Rawkode live series where we take a look at awesome open source software that will make your cloud native lives all that little bit easier. And today, we're taking a look at a project that I've been adopting within the Rawkode Academy itself, which makes us an extra fun episode. And I am joined by cofounder and CTO, Sebastian. Hey. How's it going,

4:00 Introduction

4:28 man? Hey. It's it's going good. How are you? Yeah. Good. I'm I'm just bobbing along to the electronic music. You know? I'm I'm really I think the AI like, I know people are probably gonna just go on with the show already, but maybe AI music, it it puts a smile on my face before we go live. So what more can you ask for? I I think it's great. I mean, I also love hearing my name in it, and I'm not usually I don't love having attention on me, but I will definitely listen to that in

4:52 my car. No attention on you, but I'm gonna put the spot right on you right now and ask you to introduce yourself to the audience and share a little bit about you. Will do. Alright. So my name is Sebastian. I'm the CTO at Stateful, and we make runme. I I'm kinda all decked out, so Stateful is the company. Right? We have no idea. It's a merit. And and runme is the project that we're making, which is essentially open source technology. I've been in sort of the cloud cloud native ecosystem for a couple of years now.

5:01 Guest and Project Introduction

5:26 Spent a lot of time at Sauce Labs helping with, like, test automation and then made my way into cloud native PKI, you know, service meshes and the TLS mutual TLS aspect of that. And, you know, about four years ago, kinda went on this journey to start a company and, worked through this, problem that I still think is unsolved, but, like, I think runme closes the gap. Well, I'm hoping that runme will close the gap where I think we our tool chain is too fragmented. Right? We have a we have a terminal. We have a browser. We have an

6:00 editor. We have a cloud console. And anytime we we use one or the other, we actually have to switch into another tool. And I call these sort of, like, default lines between, you know, the seventies I've created with POSIX, Unix, and and the process model that's been so successful. But in the long run, you know, essentially, it's a lot of tech debt. You know? I'm saying this in a in a sort of, like, loving way because I am also in love with the terminal. So before we obviously, before I get too deep into that, what came out of that is sort of

6:30 the idea of flipping it on its side using a notebook UX to bring all these different tools into one place. And then also, you know, layer a a CLI, you know, not over it, but, like, over the same core, you know, so you can have sort of a multimodal way of interacting with, you know, tools those tools and, you know, the workflows that you're describing, the task that you're describing, that sort of stuff. And I really enjoy talking about this stuff, and I can get really deep into, you know, Chrome architectures and all that. But, like, I'll leave it at

7:02 that intro, and I'm sure we'll get into it. Yeah. I like that early on you've already mentioned, like, multimodal. So, you know, before we go live, you know, full disclosure, I was talking about all the different things I've tried in the past to do this exact thing. You know, there are there are no shortage of tools out there, but what I I really appreciated in light and why I've stuck with runme is just that I do wanna work on the command line except when I don't, and I do wanna work in Versus Code except when

7:07 Runme Philosophy and Multimodal Approach

7:28 I don't. And, like, that is definitely the differentiator. If I want, I can use the CLI and people will see that, you know, shortly as we get into it. But if I'm already in Versus Code and I just wanna run something, the button's, like, right there. And I love that you're not really forcing too many opinions on me. I mean, there are obviously opinions, but I get to work the way I wanna work with my tools and that keeps me happy every single time. I say this every episode almost, like, don't take my tools away from me. Give me

7:55 enrich my tools in some way. And I Yeah. You gotta meet people where they are. Right? I mean, it was kinda, like, one of the choices that informed you know, we did a lot of development that, you know, like, makes that possible that, like, you know, almost is invisible. It's sort of like the stuff we are it's a little bit like how Apple designs product. It's like, you don't really see how much work goes into making it so so easy and so, you know, frictionless. And you just kinda assume that's how it is. And, you know, that's one of the

8:19 big design principles. I kinda meet people where they are. And as much as I, you know, throw the POSIX, you know, and the process model and the UNIX history under the bus, right, I'm doing it in a in a way where I'm like, I still don't wanna I don't wanna go to a WASM and say, like, goodbye. I'm out of here. Right? Because I know that, you know, we're both on the shoulder of giants. Right? And we kinda have to meet people where they are. Yeah. I'll throw out one other little not really a story, maybe just like an anecdote. But

8:46 I would say three months ago, I was fully committed to saying goodbye to Markdown from my entire life, like every repository, my mono repository, the whole work. And I'll throw Martin under the bus as I do not think it is what it's not up it's not set for purpose, right, for what we need it to do. And I started adopting AsciiDoc across all of my repositories because it's really extensible to the point where I can, you know, import lines from a make file, justify whatever and to my my readme. But then you lose GitHub support. You lose the

9:17 GitLab support for Joe, Gitty, whatever you're using, like, everything has built on markdown to the point where I was just like, well, screw all these services. I'm gonna ask you doc. And I think runme was probably the tool that made me go, you know what? Let's just stick with markdown because this is really cool. And I don't think markdown is set for purpose, but I think the way that runme integrates with the markdown is different from what I've seen in the past and that it almost feels like it worked. Like, I I still feel like I'm writing markdown,

9:45 which is nice. Whereas other tools, they always expect me to do weird structures with headings or they expect me to do code box for metadata and front matters and stuff like that. There's they share some of those things. I had some commonality, but does stick to strictly Martin code blocks, which I thought was a really neat really neat trick. I mean, that's that's good to hear. I I just I wanna say Monday or Tuesday, I forget exactly Wednesday, probably most of the day deep down in an abstract syntax tree of markdown to, like, really just iron out one of

10:14 those little kind of things that you run into. And we spend a lot of time really making it so that, like, even when you when you modify something in the notebook editor, then you get the minimal diff. Right? Like, we preserve, you know, like, lines at the end and you know? So so, I mean, there's a lot of stuff work that goes into it. So, you I'm glad you're saying that because, like, conceivably, we could build an ASCII doc AST into the notebook, kinda like, you know, at the end of the day, it's like decoding, encoding.

10:41 But I'm not looking forward to build another, you know, AST transformer that, you know, like, works out all those kings, but at least not in the short term. But I I agree. Like, am I in love with markdown? Is there something better? Maybe. But, like, it's everywhere. Right? It's like it's it's the same relationship I have with the terminal where I'm like, it I know it so well that it's like, I type faster than anything else, but I also understand that, like, it has it has a difficult it has difficulties with, like, sharing workflows, sharing what you're doing, and bringing in, like,

11:14 you know, more graphical concepts. Right? Like, a UI is a is a really, like, from a fidelity point of view, dump down way of, like, making user interfaces available. Right? So it's yeah. But I'm I'm glad you're saying that, And I'm happy we brought that to you. Yeah. I I mean, I don't think anything there are better tools. Right? But than to markdown. But Absolutely. You can't fight the gravity of it. It is ubiquitous and you just gotta lean into that. And yeah. To pairing it with runme solved all my problems where my documentation becomes

11:45 living. And that that was really what I was trying to achieve. Right? It wasn't that I I was at markdowns, like, good enough. Have to replace it. It's just that I want my documentation. I want to I want guarantees. I want proof. I want physical proof that that works. That still works across Yeah. Emily. I mean, like, one one of those sort of design principles that I just talked about was, like, you know, meeting people where they are. Right? Another one is, you know, like, to to get to a place where our documentation is not just a

12:09 thing off to the site. Right? It's not like an afterthought. It's not something that you you kinda, like, copy and paste a bunch of stuff that you currently did, and then you edit it somewhere and paste it into a markdown document irrespective whether it will actually run or not. Right? And there's obviously all sorts of reasons why it might not run, but, like, oftentimes, you would be surprised, and I'm sure you've experienced that too, that people just made up make up command line flags, then they started it. Right? Like, out of them, Terraform apply has the same ones as

12:35 Terraform plan, but in actuality, that's not true. So the idea of using, you know, like, those tools that we use to get work done and how we document it so we can essentially, you know, have the best parts of both worlds. Right? The written word to contextualize the code. And, you know, when I say code, mean commands here too and API calls for that matter to to get the work done. Right? To actually do the how. Right? That that is sort of, like, something that, like, I think is underappreciated. Right? And, like, I I feel like once

13:06 you get on random to runme and then it seems like you kinda gotten over that hump here, you kinda make that realization that, like, now I actually have working documentation, and I have my make targets. Right? So so you essentially get to this place where, like, you know, now it's now it's one of the same thing. It's like documentation, but also how you interact with the world and how you get your work done. Right? And I think that's very powerful, and and we are so nihilistic about documentation. Like, I mean, sometimes I feel like I shouldn't even start

13:32 with the word documentation. We put people to you now. They're like, has never worked. Undone here. Goodbye. Right? And that's that's a that that's kinda like what we wanna change. Right? Because it doesn't have to be that way. Yeah. Definitely. Alright. Let's say hi to Ravi and Kat. Kat has plus one for the Ascii doc support, so I guess you're gonna have to ship that now. Sorry. But the the tides are cheap. I mean, that's it. Kat's been putting stuff on my, you know, my to do list, you know, which are all good, good. And I'm I'm I'm trying

13:59 to tick them off, but I think we might have to do during before we do Asciidoc. Nice. Well, we're gonna get hands on in just a few minutes. But before we do that, I'm curious just about the the history. Right? You you give us a bit of background about yourself and the cloud native. I'm assuming at some point you woke up and when I wanna solve documentation and mark that and and runme popped out of your head. Like, maybe you could just share a bit more about what the pain points were, why you decided to build this thing, and

14:08 History and Origins of Runme

14:28 and how you managed to turn it into a company. Yeah. So, it's kinda interesting because, like, you know, when it comes to the company's trajectory, the company actually came first. And we did, you know, what, like, in startup, Lan is called a pivot. After we we, you know, sort of, like, you know, discovered is probably a better word than, like, you know, created runme. And I I'm, like, of a big I'm a big believer that, like, when it comes to both technology and products, you discover them. You don't you don't build them. I mean, you you

14:56 you hone them and you refine them, which is in the building process. So the company came first for two years, and we're trying to figure out if there's a way we can quantify, you know, developers' sort of activity in a way where they can learn from their own metrics, sort of, like almost like a health tracker, but, like, for yourself, not for I mean, definitely not for your manager. Right? Not for other people, but so that you can more or less compete with yourself. Right? And I think we ran into some real issues there, which is not even worth talking about. But,

15:28 like, we decided to sort of, like, you know, abandon it, I would I would say. But we we we always were kinda, like, focused on building on the Versus Code platform. Right? So so runme is built on the Versus Code platform. I think that's important to say because the main, you know, like, application that's bundled and distributed is is is Versus Code desktop. Right? But, you know, there's Codespaces, GitPods, Google IDX, Codespaces, yada yada yada, and and Coda server. Right? That is essentially the same relationship, you know, all these tools have is the is is is very much was very similar to

16:03 how Chromium powers Chrome and Brave and I mean, without without the UI, you know, even Edge. Right? I mean, has the same rendering engine. And, like, you know so we so we were always, like, really focused on, like, this is a ubiquitous platform. It's kinda like building on iOS. Right? So we learned a lot, you know, from building these two years of this sort of, like, coding metrics idea and and vision. And we learned a lot about, you know, the ins and outs of of Versus Code. Right? And then when we decide, okay. Well, this this concept, we

16:31 can't get it legs. Right? Let's let's figure out what's next. We we kinda like my my cofounder, Adam, and I, we're kinda introspective, and we spent a lot of time at Sauce Labs building, like, cloud infrastructure from the ground up. And when I say from the ground up, I really mean, like, data center, power density, you know, like like, really from the ground up. Not, like, you know, deploying into AWS. I wish we it was as easy, in your quotes, as doing that, but we had, like, such esoteric requirements for the hardware that we have to build our own data centers.

17:01 And, you know, in that whole process, it's just like there's so much work that you have to do and so many moving pieces, and there's no TerraForm to do that for you. There's no I mean, at the time, was probably a grant. Right? And we just kinda, like, came back to this point of, there's no way to describe what we're doing in documentation that doesn't match the shelf life of a milk carton, right, where the moment you write it, it's basically outdated. Right? So kinda starting with a very simple idea of, like, basically what you described earlier where it's

17:30 like, you know, there's a NPM install where a Go gets, you know, something where Go installs something. In my readme, right in front of me, fully rendered. Why can't I click a play button? Right? And using that sort of, like, near simple idea and then looking at the Versus Code platform that essentially has APIs for extensions to build notebooks because they essentially retrofitted the Jupyter notebooks inside of Versus Code. We just kinda, like, kinda connected those dots. But before we even did that, we started with the CLI because we were like, well, we can parse markdown into an abstract syntax

18:04 tree and then, you know, sort of noodle through, you know, your markdown document and figure out what's code and what isn't and make that executable. And we shipped a little binary at the time. It was called RDME, like, you know, sort of like a a shorter version of readme, and and launched it. And I wrote a blog post about it, and it was like I think we dropped it on f two, and it was, like, the highest traffic piece for for the whole week. I mean, we're kinda blown away. Like, interestingly, what I found was that more people

18:34 the concept resonated more than I think the implementation because the implementation was so rough. It was basically an alpha prototype kind of thing. But that really kinda, like, gave us more more confidence in, like, pursuing that direction, And I think that really crossing over into the notebook without leaving a CLI behind was also, like, kinda, like, a big evolution. And and I wanna say, like, two months later, we shipped something on runme.dev. That's kinda how the website the the project website was created. And we dropped it on the Internet. I I don't even remember we had someone read

19:06 it, and we just got hit with a tsunami of traffic. And we somehow got on hacker views. I think we were, like, in the top 50. And that, you know, that kinda, like, sort of, like, kinda builds that momentum. Right? But then you think you kinda, like, get really high up on hacker views and everything is easy, but, you know, it kinda just kinda gives you a little bit of, like, tailwind in the moment, but then you kinda, like, get do it for it. But at the end of the day, that's kinda, like, the the long story almost. Right? And and

19:31 since we have done a lot of more intricate things of, like, making sure that, you know, we have much broader compatibility and move away from the alpha stage, and I think the core runme is, like, a lot know, it's not even better anymore. It's, like, fairly stable. Right? And and but we keep layering things on top of it. So that's kinda, like, you know, the story there, and runme is sort of the the technology, the open source project, Apache two license. And what we're trying to do at Stateful is then, you know, like, pull the collaboration layer around it so that, you

19:59 know, if you run commands, they fail. I mean, it happens. Right? I mean, entropy is a problem. Right? The universe is not regular. It expands. And especially when you're working with, like, remotes, clouds, you know, there's, like from credentials to, you know, the Internet being under the weather. Right? Just things that you can't control. And what we think is a is an another clap to gap to close before we make, you know, something like Terraform fully deterministic is to just make it easier to escalate issues instead of, like, you know, getting on a Zoom call, screen sharing,

20:34 or exchanging screenshots. Right? Like, why can't we not have a high fidelity bug report with one click? Right? And that's kinda a little bit like what Stateful is for and then, you know, doing that in a secure way where you can share with the team and you have all the controls on visibility and and and sharing and all that sort of stuff. Yeah. And that's kinda like, you know, we're really early on there. If anybody's interested in that, please let me know. You can go on stateful.com, sign up for it, try it out. But if you at

20:58 the core of your runme. Nice. Alright. Thank you for sharing all of that history and context there. And I think it's time to get some fingers onto keyboards and show people how runme works. So with that, let's pop over. Mhmm. Here. So you've already said the website is runme.dev. So you can go here and get started. We're gonna go to the getting started page. And I guess we'll show the CLI and the Versus Code extension just so people get an understanding of what that, you know, what the first ten minutes in front of me is like.

21:11 Getting Hands-on: CLI Demo Setup

21:34 Well, we start with it. I don't know. What would you normally start with when you show people it? Versus code or the CLI? I mean, you know, it kinda probably depends on the use case. So, I mean, like, since you're driving and and and, you know, you you have used runme before and you put in this in a particular way, I'll probably let you choose. Because I think, you know, there's, like, probably different use cases how you would arrive at runme, and that kinda picks your journey. Yeah. I'm gonna start with the CLI just because

22:02 I think it's where I'm more comfortable. Mhmm. And then we could layer you know, I I always feel like the Versus Code extension is like that value add, but it's not it's not my bread and butter. The CLI is my bread and butter. So we're gonna start So people could just install this. It's painless for most people, not painless for me. You can install You're you're a next OS user. Right? So caveat here. Yeah. It's painful for me because I'm on Nexus. But, you know, things are getting better. So you can install the CLI. Brew is

22:32 probably the way that most of you are gonna wanna get ahold of this. That's fine. Just brew install runme. There is the Windows one. Yeah. I mean, we're not gonna go over the installation. It's pretty painless. I think that installing software is pretty much a solved problem these days, except for Next. Know solving that. Well, yeah. I'm not batching on Next. Next is the best way to install software. However, the version of runme on the Next packages, which is really, really old and I did update it, but it's not been merged yet. So alright. But either way, we get oh, I'm in

23:07 a directory with stuff. Let's go away from that. If we run runme, it's just telling us there's nothing here. So we could do runme help. And we can see the kind of main invocation points here. There's the two a. You can run individual commands and so forth. But it all starts with the readme. And I think I'm not gonna say, you know, markdown is a better purpose anymore. It's what we have. So we'll just create a very simple readme. I'm gonna keep it really simple. I hope that's alright with you. Yeah. Yeah. Like, I mean, maybe I'll give

23:40 Markdown Code Blocks and Attributes

23:42 you a little context while you're typing. Like, this is a fenced code block. Right? And there's this sort of, like, notion of attributes inside of fenced code blocks. It's, I think, part of the extended markdown standard. And, you know, the commonly, you would put the language. I mean, that's part of the standard that you can say, hey. This code block is shell or JavaScript or Python. Right? And what we do in runme, we also lay out other attributes, you know, on top of that if we wanna control certain aspects of execution. Right? But we'll get into that probably further down. But

24:11 the main idea is to use those code blocks when you wanna run code. Right? And code could be commands or literally JavaScript, Python, any interpretive language. Yeah. Thank you. I guess what was important here for the people watching is just it's a standard read me. We're not actually doing anything unique here. This is probably what you're shipping already to GitHub. GitHub is parsing this. It makes it visual, but it doesn't make it interactive. And that's really where runme shines. And Mhmm. Kat wants some ASMR of my keyboard. This is my precious. I've had this for

24:45 a while now, and then I'm not letting it go. I know when I'm on a stream, I should be using, like, my really quiet normal one, but then I just don't get it just it doesn't bring me joy. Right? And it doesn't And also when you're not talking, people know that you're working. Right? I mean, it's sort of, like, kinda like when people, you know, just say Mhmm. Mhmm. And they're not, you know. It confirms that you're doing something. That's that's true. Yeah. But that backs against you when you're on a call with someone that's one to one, and I'm looking at

25:12 them, but really I'm like, type it out. Type it Type it So anyway, let's not go into my terrible working habits. So if we run runme now, things change a little bit. We've got a couple of what it's saying are unnamed tasks. We'll get into that in a little bit, but it does allow me to run and select each of these like so. Oh, it doesn't like that. Yeah. Also, you're on a really old version of runme three zero. Oh, I don't know why it did. I mean, my my guess is, like, that you you are, like, on an ancient version

25:53 music. I I I am. I have downloaded the newer ones. So this is quite an old one. It's probably built by Nick's. Right? Because it has also has the the Unix epoch at zero nineteen seventies. There we go. Let's just kill it. I think it's it's whenever I use comma, I'm not gonna do that anymore. That's a horrible next thing that people don't care about anyway. So we'll skip over. Let's modify our readme. So we've got unnamed tasks. So by default and I think this is really powerful for the people that are watching, like, if you

26:29 just have a repository with readmes, with code blocks, those just work right out the gate. There's nothing that you need to do. But we do have the ability to annotate this. And I this this is where I got happy and confused with runme, but in a a nice way, not a bad way. Let's just call this echo. So I didn't know you could do this. And I says, I don't know if this is spec compliant markdown or if that spec is evolving. If I mean, I don't know if people have runme or trying to push forward that

26:58 spec. Is it a dead spec? Maybe you can share a better context. But what are we doing here with this little code block? Yeah. Right. So the so the the fence code block and I and I you know, like, it's kinda hard to piece a little bit together historically because, like, there's not, like, one authority that, like, hands down the markdown standard. It's a little bit like how the web works. And, so the fence code block, I think, was introduced because the previous notion of a code block didn't have any annotations, any attributes. Right? So the idea with defense code block

27:28 was to first encode what language it's in. And what we've what I have noticed is that Jupiter as well as some other I think Jupiter mostly, but also Google and a couple of other markdown based tools, they use this these attributes. Right? So now where you where you have name echo, it's a JSON encoded, you know, like, sort of payload in there that most almost every I think, like, it might actually be part of the standard. Will it like, every renderer will ignore. Right? So if you render it in in Versus Code or in in GitHub,

28:01 it will just not appear. Right? However, you know, the renderer inside of GitHub will obviously parse that it's shell and then sometimes apply some syntax highlighting. Right? What what is sort of a nice side effect is that these attributes then can optionally be used by any form of, like, you know, markdown processor, you know, you well, that's a renderer or, like, something that we do where we transform it into a different representation, which is a notebook. You can, you know, insert certain attributes that, you know our metadata, essentially. Right? Like, you you don't wanna, like, you know you know,

28:32 soil your code with some extra information that really, like, you know, just confuses whoever is the consumer, the reader of it. So it gives you the ability to, like, in encode, you know, metadata that then, you know, informs how the downstream processing works. Right? What you've currently done is you've given the code block a name. Yeah. And that that's what like I said, that's one of the things that I really like because I played with a lot of tools to try to make documentation 11. And what they they tend to do is, like, enforce some sort of hierarchy for headings or

29:03 comments within the code block. Right. And and I feel We don't wanna do that. I don't want to I I feel like that's it's pollution. Right? It's it's detracting from the value of the documentation because developers are what actually see this. And what I loved and don't expect with us, well, JSON payload after the language is that it is stripped out by GitHub renderer, etcetera. It doesn't it doesn't sophisticate what I'm trying to tell anyone looking at documentation that they haven't come across runme yet. Right. So yeah. And what what we've done is, like, we

29:32 we default to JSON, but if you could also use essentially, like, HTML attributes. You know? It's, like, literally pretend like it's an attribute of an HTML tag. I think that's what the initial spec has. You you still have to do the the the curly braces. And, actually, it doesn't do it doesn't do quotes. Right? And by the way, you don't have to do the the quotes on the on the beginning and the end. A what? Yeah. So this will work. Yeah. And, yeah, and and this will work too. So, you know, like, what we've noticed is that the

30:05 the spec allows you to, like, use your your custom form of encoding, and we default to JSON because it's just a little it's more readable. I have, however, noticed that Google doesn't like it, so we'll probably just continue. Like, when we when we parse it, we'll probably write it back in the way we parsed it instead of always forcing in JSON, which is what currently happens. But, yes, that should work. Alright. God. I didn't know that. That's pretty cool. Let's see what happens if we run I mean, if if you're on you know, the the the one thing I will say

30:32 is the caveat might be that you're on three zero two. Your old version might be too old. No. It's it's picked it up. We've got echo and we've got Oh, yeah. Right. We've got really alright. Nice. Let's I'm not won't bother running those again because those are pretty dull and we've already seen this now. So let's remove this. But obviously, our code blocks can get quite chunky. So let's say we wanna do an l s, a p s. I know these are horribly contrived commands, but we'll do bash dash c echo hello. Eventually get back down to hello world.

31:11 So, yeah, not realistic. However, when we're presented with this, one of the things that I also really like about this product is that we have the space expand command, which will actually drop down and show me everything that I am going to run. And it's just such a simple thing, but very, very cool. And we can run that, and we get hello, which is nice. Yep. And to to add and I I can maybe show this later in the newer version, we will also if there's a preceding paragraph, we will show a a sort of teaser

31:40 of that paragraph after the commands. So it it kinda, like, contextualizes. You know, if it says echo, it could say, like, you know, prince hello world. Right? I mean, it probably doesn't need that form of documentation because it's obvious, but, like, with more complex commands or something like make deploy, right, you might wanna, like, add what it actually deploys. Right? And You mean like this? And it yeah. Like, if you have a preceding paragraph. So if you wrote just like yeah. Exactly. But you have to be on a on a later version for that to be displayed.

32:16 I have one. That does not look like a latest version to me. I I think, you know, like, your your build system, your next probably, like, is tricking you. Alright. Well, I'll let you show the cool stuff then. I'll I'll just show what I can. But, you know, the fundamentals are not different. Right? It's we we've just done a little bit more, you know, like, work on refining the the user experience. Yeah. Someone's at my door, but I'm gonna just ignore that. Now something that I only discovered yesterday, and I promise you, I've been using runme

32:49 for weeks, is that you get to runme list, which just throws them out like that. So and there's that description, which is cool. Right. Right. And that description is basically then also showing up in the in the t y. It's the it's the same idea. One thing I I do wanna mention because I think you have pointed out, like, a very important feature is naming code blocks. By default, the code blocks are not named. They are being hidden. And and the idea here is kinda, like, to create a public interface in the CLI. So, like, you you the ones that you

33:19 name, you're basically exporting. You know, if you're a program on the export function where you make it public, you oftentimes, you know, like, mark that as, like, this is my public interface. So it's leaned, like, you know, on that same idea that you can give an entry point that is more narrowed down. Right? So that that you don't overwhelm, you know, people that come to your readme, to your documentation with all the code blocks that are possibly available. Right? Yeah. Cool. Let's run help. So the I mean, I guess we should show Versus code. Right? But what we've essentially shown

33:50 Key CLI Commands

33:57 is the interactive two, which allows us to select commands. We've done less and we've done run. There's the format to a canonical format, which I've never run before. I don't know what that does, so maybe we can get into that. And you offer shell completion, which I didn't know either. So, I mean, my life could be a lot easier even after this session, which I'm already excited about. So. Well, you know, it's all about education. Right? So we all learn, and I learn from this too. Mhmm. Yeah. So if you wanted want me to quickly say a word on format.

34:30 So format is essentially, you know, it prices all your markdown, sort of, like, runs it, you know, like, ingested into an abstract syntax tree and then renders it from there. So what what will happen is, you know, for example, if you had, you know, irregulars in, like, how, you know, your attributes are, you know, encoded in your fence code blocks, it will normalize that to all JSON. Right? So it's it's basically almost kinda like, you know, take take an existing markdown code base, and then you can run it through a c deserialization and a serialization step and write

35:04 it back. And what that will do, especially when you get started on runme, is, like, runme is really like, we spend a lot of time making it so that we change your markdown minimally, but there are certain things that people do in markdown that is really difficult parse into a linear representation like a notebook and then reconstruct. And, for example, like, what lists inside of, like, on what are lists inside of and then having code blocks inside of that is just a little difficult. Right? I mean, like, you know, preserving that information and then reconstructing it, especially, you know, since you also

35:35 can edit notebooks. Right? So, you know, this is a long way of saying we kinda, like, get ahead. You can run the command. You could do that the first thing if you, like, deciding to implement this in your repo. And then the diffs that come after are, like, extra minimal. Right? Because they're, like, really just the edits that you're making and not some sort of, like just because more you know, runme is slightly opinionated in the way it run writes markdown. Obviously, you know, we try to be as accommodating as possible within, like, those constraints. Right?

36:01 And that's what the format command is for. Ah, nice. Alright. Let's do one more thing on the the CLI and then we'll pop this open in Versus Code. So now that we know from your chat earlier on that the original name was r d m r d m e. Right? Mhmm. Yes. Know, open source projects particularly, they like to have a readme that is for users of the project. Right? And then, typically, you'd have some sort of contributing dot m d, which could have more documentation. So I just wanna show that this works across multiple files and directories and whatever. So

36:41 contributing, and I'll name it as well. Do I need the braces for this format? Yep. Yeah. Okay. Yeah. That's that's just to terminate the all the attributes. Right? And I see it. Oh, come on, New Shell. You don't like dash p? That was a horrible way to do it, but it it'll work. And I'll call that. I mean, the markdown name, as far as I know, doesn't actually mean anything, so I'm gonna call it arbitrary. And then we'll have another shell. And then we'll talk about other things besides shell because I don't know the answer to

37:22 that and I am curious. So Mhmm. We'll call this nest ed. It's just as echo nested. Okay. So we've got a contributing file. We've got a deeply nested world dot m d. All our tasks are named. We run this and we have nested here and contrib here. So it's like it scans everything below my current directory, and I think please correct me if I'm wrong. If we're in a GET repository, it scans the entire repository for tasks. Right? Correct. Yeah. So so the way it works, it will it will honor your git ignore just so, you know, like, if you, for

37:59 example, have, like, vendors like, node modules, right, like, the same directory, it will skip all of those. But, yeah, we'll traverse the whole tree and then and then identify markdown files, parse them all, and then and then glob them, so, you know, so to speak, together. But then also filter out all the unnamed task unless you hit you right now. Right? And but I I don't think you probably I don't know how to do Yeah. Yeah. So it's it's the same thing. But that way, you know, you kinda and and you're right. If you're, like if you're deeper down

38:26 in the directory, it will actually walk up and check if it's a git repository. And that's this is behavior that you can change, and I know that you you opinionated about them. I I agree in mono repos. That makes sense. But the idea really is for you to make it a no brainer to run, you know, like, important commands irrespective of where you are. Right? Even if you do runme run and then specify the name, it will run from any directory. It will always anchor the current working directory based on where the file is. Right? So that's just for convenience

38:55 so you don't get, like, lost in in the directory tree. Alright. Okay. So I hadn't really appreciated that. So now I'm curious what happens and sorry. I'm gonna go off track for just a minute. Right? So let's have echo. We'll call this echo button nested, and I'm gonna give it the same name. How does it handle that then? Does it does the anchoring to the this directory? Yeah. So when you have well, so that this you know, this old version, so I'm not entirely sure. Oh, in three point zero. But what will happen is, like, if you have you know, if you

39:33 use a TOI and you have two tasks that have the same name, both of them will show up. They will just have, their file that's associated with is always next to it. If you do it runme run, it will just say, like, hey. I found two. Pick the one you want. Okay. Yeah. So from here, we can select the echo that we want. Mhmm. And then from If you did run me run me run and then type echo, I think it should, you know, prompt you to yeah. Nice. Okay. Okay. Very cool. Now I've not tried this before and I don't

40:08 Interpreter Support

40:10 know if this is a dead end, but I'm gonna ask. Does runme support extra languages on the Fence code block? Can I do Python? You you should be able to. Again, caveat is, like, I don't know if it will work with the three point o version. Because, like, that's, like, you know, we have three eight now. We did release a feature that we call sheeting. Right? I like this leaned on how the shell handles it. So what we do is, like, when you use Python, JavaScript, anything that's interpreted, we we we basically look for a binary.

40:46 Right? And we we kinda have a map mapping list there where, you for Python, we look for binary called Python three. Right? And then if we don't find that, we look for Python two. Right? And then, yeah, for for Dino, use Dino. You can also do TS for TypeScript, and then we will attempt the different TypeScript run times. Right? Ah. Do I have Python? No. I had Dano. Alright. That'll do. Yeah. But I think you might be too many releases behind. But, like, you know, may maybe just try and see what happens. Yeah. Like, think you're too many Oh, I

41:22 did name them. That's what it is. Oh, okay. Cool. If I show unnamed now Yeah. Yeah. Yeah. Yeah. Yeah. Got them. Okay. There's demo. Deno log demo. And this is the Python one. So ah. Yeah. Okay. It it will it will work in in 3.8. But, like, in a in a in a much more like, 03/30 is old. I think we're talking, like, you know, like, almost a year old. Yeah. Sorry for my my very old version. But, you know It's it's okay. I I'll let you stick your hands on your keyboard very, very soon. I will take I was

41:56 gonna say I I can show that. But yeah. So so, you know, just to close the loop there, there's a default mapping list. Right? And it it it looks in your path, but there's also, an attribute. And it's easier to do this in Versus Code because you can kinda get a little list of them where you can set the custom interpreter. Right? So if you had some some language, you know, like, that you created yourself, you can associate a cell with that interpreter, and it will just run it with using your custom interpreter. Alright. Well, I have opened in Versus Code.

42:27 So this is the the same readme that we were working against. Right? So So if you hit the play button on Deno I'm not sure if Deno works. You might have to do TypeScript. Because, like, at the end of the day, Dino is TypeScript. I know that Dino.log is the Dino flavor of, I guess, TypeScript you could call it. So, yeah, that probably won't work. Alright. So, okay, let's start with this simple example. Right? Just and then we'll talk about how we configure tasks. So Mhmm. This one here is a standard shell exec. We had to play but

43:05 What is that? What have I done? Oh, I know what this is. This is me. Sorry. Not only am I running next, but I use new shell. Oh, are you it's it's it's actually dashes, not, you know, like, not the way you turn it from there. Yeah. Let's see. Rust backtrace. Why is it running Rust? That's crashing my shell now. I should I I should just stop playing with new tools. That's that's the problem. Yeah. I mean, the the problem with with broad compatible shell support is that if they're not, like, POSIX and and and sort of Unix compatible,

43:55 like, 100%, it's it's you know, you really, like, run into all the the corner cases. Yeah. Is it shell at the top? That should be right. Yeah. That's right. Yeah. I felt like it did. Also looks like it's trying to execute it. Yeah. Because, like, this all looks right, but, yeah, that does not look right. Yeah. Let's just say it's my fault. So I'm not Yeah. I mean, I don't wanna, you know, blame anybody. Oh, this is I think this is using his own downloaded version, which again, I'm on Nexus. So there's always a world of hurt there. Why don't we

44:33 jump over to your screen share and you can actually and I'll just shut down my computer and go to bed and you can take over. I could show the happy path. Yeah. To to be fair, it's it's it's a lot happier, you know, if you if you don't have a a whole lot of custom and and new tools. So I'll share. Right? Yeah. Please. Let's see. I'm just gonna do entire screen. So I'm gonna is that visible? It will be in just a moment. I'm gonna swap this out. And, yeah, I can see your Versus code.

44:43 Hands-on: VS Code Notebook

45:04 Take it away, man. Cool. Alright. So maybe I'll I'll kinda, like, pick up where you left off. Right? So, you know, for example, font mailer, you can encode in TOML. You don't have to use YAML. You know? Like, so we we kinda, like, try to be broadly compatible. But in this case here, you know, I'm using Python. Right? And, you know, like, obviously, you can write this over here or you can just select you can change the whatever language you are using here. Then, you know, we'll just change it for you, right, because it serializes. But, obviously, this

45:40 is not JavaScript. It's Python. And I think what you were trying to do is run runme, and and this is the the latest, you know, 3.83, which has the the documentation kinda teased here. Right? If you would like to find out more, yada yada. But, essentially, you you know, that way you can kinda contextualize what the commands actually does. Because in lot of ways, write, install this thing and then run this step and run this step. And in the CLI, you, you know, your space constraints, but, like, it still helps you understand what's actually going

46:13 on. Right? So now if I go and run this escape Confluence step, right, which is Python, it will just run Python. So it eventually just executes this here. Right? And for what it's worth, it does that for, like, all of the interpreted languages. If you need a binary or a jar of some sort, you probably have to build it first anyways, and then you can just run the binary. Right? So you just run it as a command. What else did we show that didn't work? Just so I closed the loop on it. So let's see. One thing that, like, you

46:52 know, is also kinda important to understand or, like, helpful to understand is, again, you know, we scan the whole directory, so it doesn't really matter where you are. But what does matter is the proximity where you are on the directory tree, so the sorting will be different. Right? So the the idea is, like, the the markdown files that are closer to you, right, in this case, I have a docs folder. Right? When I'm in the in the directory here, they will show up first. Right? And then, you know, as you can see here, there's a, you know, dot

47:24 dot readme. So it traverses out of the directory. Right? The idea here being is, like, the closer you are to the markdown file, the more interested you probably are in the tasks that can you know, are contained inside of it. Right? So there's a lot of, like, kinda, like, you know, thought that we put into that. Not sure if that resonates. If it doesn't, you know, please create a GitHub issue. I would love to hear, you know, why and why not. So so yeah. So the you know, this is kind of a terminal experience, and and David's

47:52 done a a a great job showing that off. But, you know, once you get into the notebook, the other things we can do. Right? And the reason why that is because we're not constrained to a character interface. So I'm not gonna go through through installing all these prerequisites because I've already done that. But a thing that we can do is, like, inline cloud resources. Right? So instead of, like, some sort of esoteric command with, like, lots of command options, you can literally copy and paste the URL. Right? So if I go on here and open that, I get my

48:08 Cloud Resource Integration

48:23 runme c I clusters in my Google console, and you can obviously do the same thing for AWS. But when you hit the play button, it will expand that UI right into your notebook. Right? What? And I didn't know that. Yeah. Well, you know, that's why we're here. And and so another another useful feature that we found is that you can kinda, you know, create these sort of, like, session carbon copies of what you're doing. And in fact, even in the session file, we will we will render the underlying API's, you know, response. Right? So if you're recording

48:48 Session Recording and Sharing Output

48:57 yourself, you in the markdown file, right, you might not get the render UI, but you still know what was being displayed. Right? So we kinda, like, really try to, like, deliver on this concept of, like, being able to create audio facts of what you're doing. Right? If you wanna share them, that's up to you. Right? But, like, sometimes it even helps just having them, you know, be recorded so you can go back later and see, hey. What did I do? Or what was the thing at the time when I ran it? Right? Yeah. That's entropy.

49:24 That is so cool. And, you know, like, another thing you can do is click on it and insert another cell. And in in this case, since I'm looking at a Kubernetes cluster list, right, it will give me the Kubernetes cluster details. Right? So I clicked on cluster two because it's the only one that has nodes. And then, know, like, you you essentially get a little UI here, that kinda traverses into it. Right? So you have all the list of clusters and the clusters, list of nodes, and you can even go all the way into the VM level. Right?

49:58 And we're we're trying to expand that library of available, you know, like, cloud resources in the notebooks. Essentially, what this really is is a web component, which is also open standard. We're basically just building custom vendors for that. And the notebook knows how to associate, you know, these these resources. Is that using the g cloud command behind the scenes to get this information and then render it? Yeah. Behind the scenes, it uses the SDK, which, you know, yeah, which but which is also sensitive and and and, you know, tuned to pick up on your environment. So so

50:30 it's it's it's essentially using the same tool chain. So if you like, I'm currently authenticating with my account, so that way it knows what, you know, like, how to authenticate against the APIs and what authorization I have. So it's all transparent in that way. Nice. And, you know, it works for AWS too. We're still you know, this is kinda like a lot of legwork involved. You're building out these UIs. But, you know, like, you know, in a in a in a ideal world, we would have that for all of GCP, for all of AWS, for all of Azure. Right? And

50:59 it's sort of the work in progress that we're trying to churn through. Right? Another thing is when you turn off interactive the interactive flag here, essentially, what this does I mean, we're gonna show it over here because it kinda, like, brings it back to the markdown representation. It sets the attribute to, you know, true or false. Right? And the difference here is, like, interactive is really just like, is this a terminal, or is it some is it something else? Right? Is the output that I'm expecting a terminal? It will just render a terminal. Right? But

51:07 Navigating Cloud Resources & SSH Access

51:34 if, for example, you are curling an image, right, it's not you know, if you if you run it internally, you get a binary block. It looks a little bit like what you saw on David when in David's terminal when this when this Nick's crashed. But, you know, like, the notebook knows how to, like, render images. It knows how to render CSV files. Right? So what it does here is, like, it just renders the image. Right? And it works kinda like me similarly how these components here work, these cloud resources where, you know, we we try to be smart

51:36 Rich Output Rendering (Images, CSV, etc.)

52:03 about detecting what MIME type it has and then render it accordingly. Right? And this is kinda like where you're starting to, obviously, from a from a UI standpoint, break out of a terminal. But, you know, the cool thing is at the end of the day, people can still run this in the terminal. Right? And you can still and we haven't like, I still have to actually close out that ticket. If you ran on a terminal, it could pop you into a browser. Right? So I think the important thing that we wanted to do here is bring the UI into the notebook,

52:32 but don't close the door behind us for people that don't wanna use a notebook, right, which is, for example, a terminal. And, you know, so it it remains functional. Right? Because at the end of the day, you know, I'm just opening a URL and you get your cloud console over here. Right? So this sort of concept is is, like, you know, somewhat exclusive to the notebook, but for obvious reasons because we're not in the character interface. Yeah. Another thing that is is worth mentioning is, you know, like, not having the sort of clutter of, like, how do I get the

52:58 Managed Environments: Variables & Prompting

53:03 project name, you know, to be entered by the user? You know, like, now you could write some sales script and do some gum and and, you know, like, STD. What is it called? The read command and the terminal and all that. But, like, a design principle that we have in runme is it should look like documentation. You know? Like, we shouldn't have the imperative steps how to enter the project name that just caught us in documentation because it doesn't add anything to what I'm currently doing. Right? So when I run this, it will actually prompt me. Right? So I

53:33 can say, like, runme c I. Right? Where, if you put quotes on it, it will use it as a default value. Right? So I can just confirm it. Right? So that way, you know, like, again, if you're in the terminal, you can still copy and paste it. In fact, if I run this in the terminal, it will also ask me. Right? I might have to do some digging here because, like, I didn't give this a name. But anytime you see an export statement on it, it will ask you, see how it does this here? Enter your

54:02 project ID runme CI. Right? Yeah. That's slick. Yeah. So the idea is to, like you know, that way you can actually produce generic documentation but not make it so generic that everybody has to reverse engineer it. Right? And another cool thing that we do is once this is set, we don't ask again. Right? So if I rerun this, the values are known, but you can always say, like, prompt for input anyways, and then it will reask you. Right? And another thing that should work in here, so I can see my cursor. Runme. Yep. Is, once the value is also known,

54:39 the terminal and the notebook share the environments, which, you know, there's a lot of engineering effort that went into that. So it also doesn't ask you. So, essentially, the terminal ends, the notebook share a managed environment, right, that sort of transcends, you know, your terminal session. So you when you complete steps in here, you can kinda pick up on them in the terminal and vice versa. That is, like, currently, you know, specific to Versus Code because we really use the the way, you know, the terminal is integrated into Versus Code to make that happen because it's

55:09 not trivial to cross boundaries. Right? And, yeah, at the end of the day, I think it was a cluster two, if I'm not mistaken. Yes. You know, you can you can essentially just, you know, see if any parts are running. Right? Another thing that we do in the UI here is when you set the background flag, we don't block the notebook. Right? It it just drops you into a background watcher. And that one, you can also can you know, you can watch down here too. So we multiplex the terminal. And, you know, I can apply, for example,

55:45 a YAML file or install a Helm chart or whatever it is. Right? And you you could even, like, move on and just keep an eye on it here, right, because the terminal is multiplexed. And yeah. So those are kinda, like just kind of the bread and butter of the notebook. Sort of the What does the fork button do? Yeah. So the fork button is brand new and, like, you have to turn on version two. Let me see if I have that turned on here. Like, maybe let's do something down here. So echo my name. Right? So when I run this,

56:23 of course, my name is a is a brand new variable, you know, environment variable I made up. So what you can do now is you can hit the fork button. Right? You could do something like I did this before. My dog Luna, right, is my name. And so the fork button, the idea is you fork the terminal session. Right? And then you can roll it up again. Right? So I inherit the environment of the notebook in this terminal at the time of you know, when I hit the fork button. So if I had you know, actually,

56:49 if I do what is it? Just hop back for a hot second. I'm just gonna have to see cluster name. Right? This should be set here. No. It's not. Okay. The reason why that is this gives me right now. But, essentially, the idea then is, like, if you can exit this terminal, and now when I run this, you know, like so when I roll it up, it will then, you know, close the terminal and update all the environment variables with whatever I set them or mutated them in the terminal session. Another thing that you can do is

57:26 if you don't like clicking around here and, like, do use the the notebook editor, you can also hit the forward button and then just go about your ways. Right? Do your thing and then type save, and then it will grab the whole session and and and and, essentially, like, hoist it into into the notebook. So you can, you know, you can essentially start editing. Right? And what we wanna do here, and this is a lot of work because we have to build yet another, you know, abstract syntax tree, is to parse the the sequence of characters and

57:58 then and then chop it up into a notebook for you. But the idea here is to make authoring easier. Right? So That's neat. Yeah. Long I like that. You know, long story short is, like, you fork the notebook on two ways. Right? The actual content of it, but also the environment. And then whether you exit it with exit or save. So save will roll up the environment, and save will roll up the environment in literally the session and and copy it into a into a cell. So see the session, is that what those extra readme fail like, markdown fails are? You can

58:31 see you've got two cloud files and two three cloud files and two gapless. See how I have the I have the auto save on? This is like, you know, like, when we when we serialize, you know, what's in this file here, right, when we go in here, and this is the notebook diff view, but you can always do the file diff view. You know, see how this has now changed, and it has all the stuff inside of the cell. So when you when you hit save, it will only serialize input cells. It will ignore output cells. Right? Because the idea is,

59:03 like, documentation is only, you know, relevant to you for the inputs. You create your own outputs. Right? When you turn on auto save, it will create a separate file that is really, like, a carbon copy of what the inputs are, but it also includes the outputs. And it does that per session. So if I hit the reset session button here and then I save again, you know, I get a brand new file. And Okay. And, you know so the idea here is, you know, like, I did all of this and, you know, maybe I ran out of

59:33 disco. My my next door has a problem, and and then I can go on my session output and I can say generate a gist, log in to to GitHub, and then, you know, I have a secure gist here. Secure in the way that it's not listed. You know, everybody can access it if they have the URL. But I could send that over to you. Right? So it kinda, like, just makes the cuts out the steps it takes to, you know, like, copy and paste, do screenshots, that sort of stuff. Yeah. I can imagine this would be really

1:00:00 helpful, like, if you're say someone's play move runme and they have a problem, they can just create a notebook, guess that, and then pop it into the issue. Right? And and, you know, like, the idea really is to sometimes even give people a readme as sort of a starting point to platform them. Right? Like, you know, use your cluster. Here are the common things that you do, and here's a little bit of a troubleshooting section. And if you can't troubleshoot yourself, just run all the cells and then and then, you know, gist it. Right? This is also where we have, you know,

1:00:30 like, a stateful as a product come in. I can log in with my stateful accounts over here. And and, essentially, then instead of, like, creating gist, pump that into our platform, and then you get all the features of sharing it with the team, posting into Slack, that sort of stuff. But, yeah, it really is sort of for the troubleshooting. I mean, troubleshooting and also recording what you did scenario. Right? Because sometimes you wanna, I don't know. Like, something on a on a server where you are, MRF, you know, some I I don't know. Like, something that you

1:01:00 wanna, like, okay. I wanna have an artifact of that when it happened and what happens. Right? Because it's a high stakes task. Yeah. And I'm I'm editing the which I shouldn't be doing the I mean, you can. Right? You can you can redact and then create a a gist of it. One thing that I quickly wanna show before I hop on to another sort of features, What I find need is, like, for VMs, for example, we don't just give you the resource, but you can, you know, click on the SSH button here, it will literally drop

1:01:31 you into an SSH session to the VM. So that's that's kinda neat. Right? Because it kinda, like, literally, like, I'm on the node of my Kubernetes cluster. I think I clicked. Right? Or did I use instance Nided instance, but I could, you know, just h SSH into cluster two's node here with one click and, I don't know, do some sort of, like, you know, analysis work and then, like, hop out and and be done with it. Right? And it all records in my session file too. But you said that you support AWS and GCP for that. Right? That that that's a

1:02:02 color feature. I hadn't seen that. I love it. Do you plan to do the same for Kubernetes to the point if I run get pods, can I then just click show me logs of this pod? Because that would be a really cool feature. Yeah. I mean, like, you know, all of this stuff is very extensible. I mean, we did a a integration with Dagger that, like, essentially uses the CLI button layers, you know, sort of actions on top that, you know, conceivably, you could also, if you, for example, build a directory or build into a file. A directory is

1:02:29 probably a better example, could then actually list, you know, directory and the files inside of it. And then you could maybe even have a button that then opens the file in in another tab. So yeah. That's I mean, yes. Yeah. Anything is possible. Yeah. More time, more people, more hours. Like, that's Right. What it boils down to. So Exactly. And, you know, like, another thing that we have, we have a few GitHub workflows that we trigger manually. So this is kinda neat because when you're contributing MD, we have a release flow and then, you know, if I mean, not not

1:03:00 all of our pipelines run. There's you know, most of them run on push, but the release one, we we just dispatch a workflow. So this is, I think, a test no. It's actually the live repo, but I I can build a a prerelease version. That's not gonna hurt anybody. But this will literally, like, kick off a GitHub workflow. And if I open it over here, you know, you'll see it just this is your familiar UI. Are these integrations documented? Because I I don't know how I missed this. Like, do you list where these are? Yeah. There is an integration section. So I

1:03:35 think cloud renderers, AWS, Cloud Run, Cloud Platform. Yeah. And yeah. Yeah. There there yeah. Maybe a little hidden away here. For example, Dagger is in here too. And, yeah, we've there's also a lot to get to, right, which is kinda, like, I think, part of the problem, which is also why I'm moving on because there's a lot to get to. So so the other killer feature in my mind is, like, if you have a diverse team, including people like Mix and some Windows users, you can actually peer your notebooks and your documentation with, like, what I call an ops

1:04:00 Reproducible Environments with Dev Containers

1:04:09 container, which is literally just a a fancy way of saying a dev container. But, like, since you you are more operating software and not developing software, I like calling it ops container. So what I just did is my repo here, I open up inside of the container. And what that will do is, like, I have some generic container on it right now, but you could literally have any container image running behind it. I think this just has a bull's eye. Like, what is that? Debian, I think. Yeah. Debian. Linux. Yeah. And what's cool about it is now you

1:04:44 could go and lock in your dependencies, your system dependencies. Right? Like, the kubectl version, the the Terraform that you're using down to the patch version and distribute the image and just pin your image to this repo, and everybody always has the same dependencies. Right? There's no excuse for the documentation not to work because the upstream system dependencies are not met. Right? And this is obviously kinda like an advanced feature. Right? Like, I think oftentimes documentation plan doesn't work because it's actually just long. But there's another side to that coin, right, where if your documentation is right, your system

1:05:16 dependencies might not be missed. Right? And and this is just kinda like a fantastic way to just bake it into it. Right? And then distribute your repo like usual, you know, and you can manage all of your changes to your documentation through pull request, you know, a Git workflow. And but everybody can, you know, essentially have a reproducible environment and run the same stuff. Right? And without having to, you know, sacrifice, you know, the the the sort of comfort of, like, having the same notebook UI because, like, there is really no difference when you look at it. Right? It says, like, I'm

1:05:51 running in a in a dev container. Right? If I reopen this locally again and I run the same cells, it will say, like, I'm running locally because I am running locally. Right? So that's one way of, like, you know, sharing that with your team. And if you wanted to get real fancy, you could even I'm not sure if my VM is up and running. But you can also attach your Versus codes to a remote server using SSH. So you maintain the same notebook UI locally, but you are in fact running against, you know, a jump host, for example.

1:06:28 And you could do the same thing with code spaces or get pod or any of those things. Let me just open something. And, you know, you basically have the same UI, but, like, the subtle difference is, like, now I'm actually on a remote host, and you'll probably depending on how far away you are from I think this runs on the East Coast. You get a little bit of latency. Right? But you have the same you know, more or less the same tools, the same environment, but it runs remotely now. But my Chrome, you know, what I'm seeing is they hold

1:06:58 the same. Right? And I get the same features. Nothing really changes, but it it's sort of portable in the way that, like, we had a computer and made a memory. It's almost, you know, indistinguishable, right, unless you look for the details here. Nice. Yeah. And to kinda close the loop, right, because, you know, it's upstream dependencies, like, the system dependencies, you know, credentials, and then documentation workflow and task being right, something that we're working on that's still literally actively being worked on that I wanna release soon is this managed environment score. We we we really wanna create way of

1:07:37 Advanced Environment Features & Future (Type System, Validation, Secret Resolution)

1:07:39 making it visible. Right? And when I say visible is, like, also when you mutate it. So this sounds a little esoteric, and I should probably stop using computer science terms. But, you know, what you can see on the bottom is, like, what is currently in my managed environment store. Right? So when runme starts a new session, it'll look for dot infile, dot inf local files, and then load them in your environment. Right? And it also obviously does it with your dash or your z shell or c. One thing that we created, and that's that's kind of the work in process, is, like,

1:08:12 a simple type system so that you can describe your how your environment is supposed to look like, and it accounts for sensitivities of variables. Right? So one thing that I'm, well, you know, somewhat proud of is, like, I'm not shy to show you my OpenAI key because it's redacted. Right? So I marked this as a secret, and now it's being shown as a secret. So if I take a screenshot of it, I don't have to worry about leaking my secrets. Right? And if I, for example, I could even overwrite, you know, like, values in this environment story here. Let's say,

1:08:48 allow URL patterns. Right? One thing that, you know, is also not obvious, you can when you name a cell, like, an environment variable, the content of the cell will actually be stuck into the like, it will wind up in the environment. Right? So if I do something like this and then run this, see how the value has changed to one, two, three, four? Mhmm. And, you know, so, like, it it it tracks the values, you know, over time. Right? So, like, even if you mutate them, it will change. Also I mean, I seeded my environment

1:09:23 using this environment file. But if I, for example, remove a required variable, will show me, hey. My database URL is not set. So the idea here and I'm still building this out. We are you know, there are sort of two parts to this type system. One is sort of like a a primitive type that just, you know, controls the visibility and whether or not it's required, sort of a binary that you need this to run your service, your repo, your documentation. And then we'll be layering on top of that type as validation. And in in this case,

1:09:59 you know, like, it it understands that database URL needs to be compliant to a database URL. Right? So it has to, you know, actually be a valid database URL, so, like, a Postgres, for example. Right? And what that then will do is, like, if I, for example, make up some stuff, I call this Sebastian, and I reset my environment, it will tell me that this is actually not valid. Unknown database scheme. Right? And so this environment this managed environment store, you know, I almost kinda we wanna get to a place where you can include and

1:10:35 we'll probably create some sort of CRD for this. Right now, we lean it on the examples file where you essentially annotate it. You will make it so that you can, you know, type your environments. And that way, when you load into it, you know what's missing. Right? If you have a dot in file and it's partial, what's from an older version, it will show you what the difference is. It's like, oh, somebody introduced a new environment there, but you haven't set that one. Guess what? Your documentation won't work because you're missing, you know, some core piece

1:11:06 to it. Right? And, you know, like, the idea is to specify, you know, in a in a sort of, like, well formed way how your environment is supposed to look like. And then another layer that we can lay on top of it that I'm still working on is that we can also do resolution. Right? I can go use your GCP identity and, you know, like, go into the GCP secret manager or use, you know, a cloud key MS to either decrypt some stuff or grab them from a secret manager. I didn't I was literally about to ask you for that feature

1:11:38 when you showed me the episode there because I use GCP secret manager with bare glass secret references. And I was like, if you could just detect all of those bare glass secret references and resolve them with the g cloud CLI, like, that would be phenomenal. Like No. That's that's that's exactly the plan. And, you know, you probably get an environment picker where you click down here. And, you know, you can say, like, staging one, staging US, staging Europe, production. And so so, like, I think, like, it will not just resolve. It might also prevent accidents because,

1:12:11 like, I remember some company, like, six months ago posted a postmortem on on Hacker News, how they accidentally blew their production database away because somebody had their local environment configured to point at production without knowing. Right? And this is, like, highly programmable. So, you know, like, what you're seeing here is really, like, kinda like a UI version of it, but, like, what's under the hood is, like, a graph representation of it. So I can also do the same view in in the CLI. So I get, like, the same listing where it's from. And and, you know, like, the resolution

1:12:46 aspect of it, I still need to build out, but, like, it's pretty easy to lay on top of it once you, you know, once you have a specification of how your environment has to look like. And then my my sort of idea for the resolve resolver part, and sounds like this would help you too, is to ideally just use conventions. Right? Like, you know you know it's a secret, and then, you know, this looks like this. If you lower case it, that's the value is inside of the secret manager using that project. Right? To kinda, like, make it

1:13:14 really easy and not create yet another, you know, YAML file, another thing where you have to then manage your mapping. Right? But that's all kinda, like, the loosey goosey still because it's, like, literally inactive development. Right? Hey. Shit. I want it I want it today, please. Like, just Yeah. Yeah. Like, I'm I'm going to. I'm going to. Like, the thing that I wanna do is I wanna do a little bit more work to go from, you know, the managed environments to a currently like, you only really ever need to describe, you know, sort of the critical part of

1:13:42 the environment. Right? But all the other part of the environment is still in here. Right? What I wanna do is, like, just make sure that we showcase how the validation works a little bit better because the validation part is also something that then you can customize. Right? So, essentially, this database URL, when there will probably be a bunch of ones that come out of the box because everybody needs them, but you can literally also write your own, right, where you I think I used the validator library, the Golang one, and you can you can just,

1:14:11 you know, make up your own. Right? But the good news is it's gonna be inside of your repo. Right? And your repo is collocated with your dependencies. It's collocated with your documentation. It's collocated with your environment spec. Right? And then the resolution can either use your human identity, right, my GCP identity because I ran, what was it, g cloud auth login. But in CI, I can use the same thing. I just use a workload identity. Right? So that way, we get away from doing this thing where we stick all this information inside of GitHub or

1:14:44 GitLab. And then anytime we wanna move from one CI to the other, we have to go in and figure out what all these these variables are here. Right? What's this stuff here? Right? So, I mean, call me call me a you know, call me crazy or, like, maybe you have a chip on my shoulder, but, like, I think we're really handing over all of our bargaining chips to these cloud providers so they can charge us for locking us in. If we could just do something like this and then actually also make the user experience better because, like, if my environment is incomplete,

1:15:11 the thing will actually yell at me. Right? And, you know, there's also, like, a lot of stuff you could put on top of it. For example, what I really want is a little button here that says, like, ping my database and make sure I can actually connect to it. Right? Like, imagine how how many, like, you know, how how you don't have to, like, look for a needle on the haystack. Right? Where if a base 64 encoded string has a space at the end. Right? And the base 64 encoding is, like, you know, falling over

1:15:36 and you spend hours of your life trying to figure out where that problem comes from, turns out the environment variable is just ever so slightly wrong. Right? Yeah. It means you could like, one of my use cases is which I think you're gonna be able to support just by everything that you're building here is, like, you know, there's a command for deploying to production, but there's a big note above it saying you need access to these secrets. And it's like, you could just have little text saying, hey. You can run this command. And, like Yeah.

1:16:01 I I did not expect to see this, and I could not be happier to see this. This is a fantastic feature. Yeah. But what what we're trying to with runme is is and, you know, like, you kinda, like, wind up wandering off into, like, little pockets because, like, certain features resonate immediately. But what we're trying to get to is, like, you know, not to solve the greatest problems of computer science. I wish I could that. I'm really not that smart. Like, you know, key versus NP and then all that stuff. But, I mean, I didn't think I was ever

1:16:28 gonna say I'm gonna build my own type system, but, like, you know, I wind up doing it. But what we wanna do is, like, have essentially a complete tool a complete tool chain, a complete suite that solves these problems that we're getting bogged down, especially as humans because DevOps and cloud infrastructure, instead of, like, the left shift have worked backwards from production. And I feel like now we have sort of, like, this massive gap in between. We have all this tooling that, like, things like machines and treats things like machines, and it works really well with

1:16:59 that. But once you hit the human, it's kinda like, oh, you have to fill in the gaps. Right? Like, here's the environments, you know, the angles that you have to fill out. Good luck. Find the values yourself. Right? So I'm not against, you know, the left shift, and I'm not against developer tooling, but, like, I think making it so that we can connect the human better to, you know, all the work that we've done in the last ten or fifteen years, I think it's sort of like we had a developer gap actually is. Right? It's like,

1:17:27 how do we, you know, make no difference between a human identity and a workload identity? Right? And I think this amongst, you know, all these other things is a way to bridge that gap. Right? Is it perfect? Probably not because it's very incomplete. But I'm glad to hear that, like, I just recruited David Flanagan as a as a better user. Hey. If I could give you a beer or a high five right now, I totally would like I I could be happier to see this feature in development. You and you mentioned something earlier that but now it makes a whole

1:17:55 lot more sense. Was it you said you were gonna support DuraEnf. Right? I'm assuming that's part of this this work. Yeah. Okay. Yeah. So DuraEnf is is kinda, like, helpful in two ways. Right? A, people already use it in cat. We'll be able to ditch a lot of, like, extra code you put into your task files because, like, the way we share environments between cells is not we don't we don't share it the way a bash script would. We actually snapshot the environment before and after and then and then put it in this managed environment store so we can also then port

1:18:26 it between modalities. Right? Modality, you're being a notebook. I mean, another thing that, like, you'll probably see is we can also run blocks from here. And what we wanted to do is, like, we didn't want people to fall into yet another fault line between one modality into another. So if you complete the environment over here, it was really important to me and to us that then when you run it on another in another place that it has the same values. Right? So this is why we have this managed environment store. So now the problem in the theory of

1:18:55 interest solving is, like, it's just a program away of of, you know, I guess, specifying a dot in file. Right? Because it allows you to write shell. The other thing that it allows you to do is, like, there might be some prerequisite steps, you know, whether it's, like, you wanna run some stuff where, you know, like, what's the command to get the Google project. Right? It's like g cloud config gets. Right? You might just wanna run this and and and and stash it into environment file. Sorry. Into an environment variable to then use it downstream in your documentation. You wanna run it

1:19:25 every time somebody starts a new session. Right? So it kinda gives you the ability to define some prerequisite code that needs to run, in this case, stash. So it it it kinda checks a lot of boxes, and then I also like the way they authorize. Right? They they ask you, like, are you okay with running this? Right? It kinda fits into this runme philosophy where we want things to be easy, but we don't want them to be easy at the expense of being secure. Yeah. Cat was just saying that's one of the things that blew our mind after already

1:19:54 adopting the tool. I mean, same for me. I've been using runme for weeks now, and I could not be more excited for this end store. So that's amazing. Right. And and, you know, that's something that I wanna release, you know, ideally in the next four weeks. If you if you're really curious, there is a little bit of documentation on I mean, kinda like the principles of it on the repository. By the way, the managed environment, so I call our store because, like, you know, when you when you figure out the environment, that's what you left with. Right? It's like,

1:20:26 I I blacked out the let's call it freaking so we don't have to use exodus. So it's called because also a much cooler three letter acronym than inf. So internally, we call it the. But in in the UI, you will just notice that there's another tab down here where in the CLI, you can run snapshots. But, you know, this is the idea is very simple. Right? It's like it's a very simple type system that basically just describes how the environment needs to look like, right, both from a security standpoint so you don't leak secrets, but then also has validation built in.

1:21:01 And then with this sort of, like, three way relationship, you have a name, you have a type, and you have a value. You know, like, when you have two, you can find the third one. Right? And the caveat here is, like, to find the third one, you can take human identity into account. You can take into account what device you're running on. Right? Are you running on a code spaces instance or on your local laptop? Right? So there's a lot of, like, security hygiene you can do out of the box without burdening the user. Right? I

1:21:26 mean, whether it's, like, rotating certificates. And I build it all on on GraphQL, which I was, like, kinda, like, going back and forth on until I thought I saw the dagger was doing it too, I was like, well, if they're doing it, then why should I be doing it. But what that helps me do is, like and you don't have after I graph you all. Right? This is really just to serialize sort of what's going on inside of that in store. This is all kind of inside of a kernel. The UI you interact with is this, right,

1:21:53 where, you know, the specification file. But what it allows us to do or, like, allows me to do is, like, I can have a simple dot end example file where I can have a CRD or I can have the the the sort of, like, on ramps into how to specify an environment that the front end for that can be completely agnostic to the environment store. Right? And and then, you know, like, here, you know, whether you use a shell command to resolve the values, right, or you use some custom webhook, or you use the stateful products, or you

1:22:24 use a secret manager. Right? It's kinda programmable in that way. So it kinda like yeah. It really was to, like, leave the room open for people to, like, be opinionated about how they wanna resolve their configuration values and their secrets. Right? If they wanna build their own or if they wanna use what my company builds or if they just wanna use a vanilla, you know, secret manager inside of AWS or or GCP. Yeah. So, like, a lot of work has gone into this, and I feel like, you know, anytime I wanna release it, I find something else. But

1:22:53 I think I just kinda have to jump jump the shark release it. Awesome. That is super cool. Yeah. And, you know, if anybody is, like, sort of computer science y and interested in, like, how this stuff works, it's all, like, a little go kernel. And, you know, like, my plan would be to continue to develop it inside of runme, but, like, what I really wanna do is spin it out into probably a tool called OWL that really only does this one thing, which is, you know, specify, validate, and resolve environment variables and and do that in a way where you can use

1:23:28 human identity and and workload identity. Right? And just kinda do away with all these paper cuts. Right? Yep. Awesome. Yeah. So I took you on a esoteric, you know, turn there, but I feel like this is an unsolved problem of, you know, software and, you know, the the what is it? The 12 factor movement has done a good job separating configuration from the environment, but sort of at the detriment of the human. And I'm trying to close that gap now. Right? And and I think it was, you know, right to do that, but it is annoying that we now, you

1:23:59 know, have nothing that makes this easy, and I think this will resolve that problem. No. I appreciate that segue down this path. That is you know, this is exactly the thing I wanted. Well, not that I wanted to see because I didn't know I was going to see it, but the fact that now that I know this exists and that this problem is being solved makes me a very happy man because I have spent weeks in fact, probably months going from secret manager tool to environment tool, from dot env to dot env x to in physical to Google secrets manager to one

1:24:28 password to Doppler. I've been trying to just rack my brain about how do I fix this because, you know, we have config. We have secrets. They have types. They have to be validated. And it's Right. A solved problem. And now I've just got the happiest smile on my face ever because I know that you are going down this path of fixing this thing. And I I I will be your alpha tester, your beta tester, and Yeah. I mean, I I wanna I wanna get it to a point, honestly, and I think this is totally possible doing a little bit

1:24:55 more of that work where going from one secret manager to another is is changing one line. Mean, granted that you use the same conventions, but, like, we could even have a transformation step. Right? That uppercases it all remove, like, make snake case out of it or makes k pop case. Like, that sort of stuff is also, like since it's so programmable, it's it's you know, like, SOPs. Right? You, like, even, like, delegate it to another tool. But the idea is really to, like, do all the front load, all the, you know, the specification and the validation

1:25:22 that when you then, like, go reach into it or, like, the other way around, when you reach into it, then you can also check, does it actually need the stack. Right? Yeah. But But literally make that like a no brainer. Right. And because you know how to resolve all these values and you have type information and you potentially know where these values come from depending on how deep it goes, you could do automatic secret rotation as well. Oh, and it could run me and all this other really cool. But, like, I mean, you could be working on this for

1:25:47 the next six months, adding new features. I don't think you run out of ideas. I mean, I I built this thing because I gotta talk into, you know, the the rejects event at at KubeCon in Europe. I had sort of, like, a conceptual prototype, and then I got to talk in. And then within four weeks, I actually have to build it. Was probably the most stressful part of my life. Conference driven development at its best. Yeah. That that my my wife was out of town for, like, two or three weeks of that. And, you know, I guess it wasn't good

1:26:15 for my health, but but, you know, I I really wanna get it out in front of people. And I think there's a lot of, like, sort of misconceptions around that that problem is solved. Because people say, like, secret management use vault, use you know, it's not a it's not a it's an un it's not an unsolved problem anymore, and I I have to disagree. I think it's solved in a way where we're giving away all the bargaining chips to all these big cloud providers. They lock us in, and then we entirely remove it from the human.

1:26:40 Right? So, you know, like, I think this is also why platform teams are so busy because they have to bridge that gap using, you know, like Jira tickets, right, or Zoom calls. Right? And it's silly because it doesn't have to be that way. Wow. Alright. And that's just normally why I'd say what's coming next, but you you've more than covered that. So Yeah. I mean, that's coming. The runme terminal is probably gonna go out of better, like the thing where, you know, it rolls up. And, you know, the idea is really to kinda connect the dots between

1:27:12 or, like, remove the the boundaries between the modalities, right, so that, you know, people are comfortable in the terminal. They can stay in the terminal. We also wanna bring most of that functionality out of Versus codes. You know, there will probably be terminal commands that, in other ways, are gonna try to bring the same integrated way together. It's a little bit more difficult because, you know, terminal is an island and and really just kinda, like, continue to do more of that. And, yeah, like, I think for what it's worth, like, know, just people kicking the tires,

1:27:44 telling us what resonates. Right? Like, I mean, there's a lot of work we could be doing. You know, like, I think we already put a couple of things on that stack of what we could be doing on a road map, but we really also wanna be user user feedback driven. Right? So, you know, people using it. I mean, you kick the tires. I'm probably gonna go back to filtering and searching the t y. Right? I we really wanna unblock people. I usually kinda, like, split my time between doing the the things that come in and then the

1:28:10 larger development projects. Yep. And we're doing this the same way with the team. Yeah. But those are kinda, like, the more tangible, you know, next couple of projects that are gonna come. Nice. Well, I would encourage anyone watching to go check out the repository, get it installed, start kicking the tires, open issues, and keep you and the team busy because this is a Discworks. This is a product that just solves a lot of paper cuts, right, frustrations from development, especially for me. And I'm on a repository, but or anyone doing cloud native microservices. Right? We've got all this documentation and internal

1:28:22 Conclusion and Call to Action

1:28:44 knowledge that needs to become shared and commoditized across your team and your organization, and runme is a fantastic tool to do that. So thank you so much for building it and for spending the last ninety minutes of your life dealing with my next source, but also showing us some really cool stuff with what's coming along. I love talking about this stuff. I probably don't do it enough because I'm I'm, you know, usually busy, like, trying to, like, go down the the AST rabbit hole or, like, the Alstor rabbit hole, but I appreciate, you know, that you invited me to come

1:29:12 on the show. And, you know, maybe we can do it again when the Alstor is a little bit more developed and we can kinda, like, really go a little bit deeper. And, like, I think the resolution part of it, you know, is gonna be really important. Tire kicking. Yes. Russell is kicking tires for you now, so that is awesome. Alright. Thank you again for joining. And thank you for everyone that's watching. We're gonna call it a a night. It's getting late for me, but thank you so much. And, we'll definitely check back in with you

1:29:39 and runme in weeks and months time to see what's happening. So thank you again. Have a great day, and we'll see you all next time. Thank you. Bye. Likewise. Bye.