1:51 Introduction

1:51 Hello, and welcome back to the Rawkode Academy. I am your host, David Flanagan, although you may know me from across the Internet as Rawkode and, of course, this channel. It's been a while since we're streamed, you know, a bit of an update. My office burnt down in April, and I've had to rebuild from scratch. So apologies for the lack of amazing, hopefully amazing cloud native and development kind of content. And I'm really excited today because this is a tool that I have been using for a little while now, and I've started to go kind of all in within

2:23 my model repository and using this to build out development environments that are just a joy to work with. And today, we are taking a look at Devenv, which is a Next based build tool that provides a great development experience. It's reproducible. It's fast. And as I said, a pleasure to work with. And to guide us on our journey of understanding Next and Devenv and all of the amazing things we can do for that, I am joined today by the Kashyx founder and maintainer of the Devenv project, Khozar. Hey, man. How's it going? Hey. Hey. Thank

2:47 Guest Introduction and Background

2:56 you so much for inviting me. I'm happy to be here and to share the journey of what we've learned with Nicks. No. I mean, thank you so much for for joining me. I'm generally super pumped, excited, although this is my excited face in Scotland. But I'm super excited to be diving into this today and sharing it with the audience because I have found that my life from a development environment standpoint has just been lot simpler since adopting this tool, and I wanna share that with the audience as well as get history, context, flavor, everything else that you can share about

3:27 your journey along the way. So That that being said, I'm gonna throw you under the bus and say, why don't you just tell us a little bit about you, what you've been up to, and, you know, give us all the details. Alright. Thank you so much. Yeah. So let's see how long of an intro we can do. So I've been I think I've been part of the next community for quite a while. It's been about ten years now. And before, I was doing just consulting and a lot of Python and and stuff and a lot of the frustration with packaging

4:02 let me and and I was a Gentry user before. Like, a lot of the frustration with you know, all around has let me into Next very early on. And I've I've kind of never looked back, and and, you know, the early days were the early days, so there was a lot to do. But we've come really far in the in the last ten years. And then about, like, I think, six years ago, I was really happy and and really, you know, delighted to work with. That was my kind of first time consulting gig where we were, like,

4:39 essentially using Hydra to create these, like, huge matrix matrices of different, like, kernels, different versions of software, and, like, running benchmarks with on, like, networking cards and drivers, like, specialized built for them. And then creating these, like, graphs of, like you know, if you change the kernel version, if you change the different software versions, like, what how does that impact performance and stuff? And it's just really nice because you can kind of map through all the kernels, map through all the different software versions, and kind of generate derivations, which are, like, the the builds of of

5:18 executing that benchmark. So that was really nice first gig. And then I after that, I worked with IOHK as a DevOps lead, intro like, introducing NICs into the whole process there of, like, building the blockchain, blah blah blah. And then after that, I created CashX as I saw that. Like, I wanted to do a lot of NICs as part of IHK, but, of course, that was not a priority there, although we did a lot of great work there on NICs. So then I started cache x, and then it's been about five years now, I think,

5:54 building first binary cache, then deployments, and and then, like, a year and a half ago, we started Devenv. That's yeah. And a bunch of other stuff like nix.dev was also our effort, which we donated in the community to improve the documentation in the next land and and things like that. Anyway, lots of things. I can dive into any of them if you want. But Yeah. Awesome. Yeah. I think we'll start with the question that I hear most when I go to conferences and mention next or anything like this, right, is that there's a lot of

6:21 Nix: Dispelling the "Academic" Myth

6:32 intimidation. I think people are are scared about learning a new language even if the tool itself is powerful. And I think there's a common consensus that it's considered quite academic, but I think that tide is changing. And I'm curious on your perspective here. Like, do you see people that are coming to speak to you? They're struggling with next. Do they still think it's academic? And and do you see this trend where more people seem to be just embracing it now, in the last twelve months? I seem to think that people are a lot more open

7:00 to to using Next and Next tools. Yeah. That's a really good question. So I I think that it has changed a lot, mostly because there is a lot of people from the industry who are using NAICS and bringing that, like, mindset into it. So I I don't see like, the academic side, I don't see it mentioned almost at all anymore. I think a lot of that has is due to Rawk Arbus who led, like, the redesign of nixos.org about a few years ago, maybe three years ago. And, like, the original website was very academic. Like, you could really see, you know, it's

7:37 like talks about purely functional and all these words that, like, nobody cares at the end of the day, right, what they wanna do with nix. So that has changed a lot into what the industry is used to, which is, like, you know, showing off the features and the benefits of of using the Nikes and things like that. So I think the redesign of the website was a huge move. And then also, like, just people all around who are, like like, you know, bringing that developer experience mindset to makes and and trying to make it better and and more stable

8:10 and things like that. I think it's like no single thing, but it all kind of, you know, trickles up or trickles down to to what we have right now. Yeah. Definitely. I mean, I think the academic side for me is whenever I hear someone say hermetic or adampotent, I'm like, okay. Here we are again. It's something hard, but, you know, these things, they they mean something different in each context. And I think the next context is something that is, like, containers now. Right? We take these for granted. And I think next is maybe the next the next

8:41 kind of adoption point that we're gonna see in this space. But let's break down next. Right? Because we've said a few things. Now you said next to us. There's next. These are actually many projects. Right? There's next to language. There's next to package manager. There's next to us, the operating system. I I don't even know if I've missed anything there, to be honest, but you don't need to buy into all of this. You can pick and choose the parts you want. Right? Yeah. So I think the most confusing part is that, like, we don't really have a good name for

8:45 Understanding the Nix Ecosystem

9:11 the project. There was a times where we called it the. There was sometimes where we called it. So it's been a lot of discussions. I've been big proponent even when I was still in the foundation to to to pick a name that, like, is for the project itself that is completely distinguished. But, yeah, NICS is, like, kind of, like, the language, then it's, like, the package manager, and then kind of, like, the whole facade of of tooling. Right? And then, like, Nick so has built on top of that and provides his own interface and, for example, Devenv

9:45 as well. So it's quite a quite a few layers, and I think that's the and what used to be really hard as well that NICS was really hard to Google because it was, like, Unix and and things like that were, like, popping up now that NICS is so popular. I think Google is doing a great job of prioritizing us, but that's likely solved. But, yeah, that all creates this confusion. But, like, the the essence is you you you wanna use NICs. That's kinda like the core. NICs is like the distribution, I would say, where you get, like, the the the actual

10:18 common line. And then you can, like, slowly progress into, like, do you wanna have developer environments? Do you wanna have deployments? So, like, there is a lot of different projects. There's, like, Nick's Darwin, which manages, like, your Mac OS kind of configuration, home manager, and and then there's a lot of projects. But, like, the essence is kind of, like, the common line tool and then the language itself. Okay. So let's lean into the dev end aspect of this then. This is the project that we wanna show people today. In order for someone to get started and,

10:46 Devenv's Philosophy: Simplicity First

10:54 you know, recreate some of the things we're going to do today, which parts of Dext are they buying into. Right? It's is it the Next language? Is it Next packages? Do they need NextOS? Like, how does Devenv and Next correlate? Yeah. So one of the I don't know. I this is a bit of a thing that I like to say that NICS is kind of like the JavaScript of DevOps. Right? Because the language is like you know, it's it's an old language by now, and it's it's there's a lot that could be fixed or changed initially.

11:29 So we're kind of stuck with what it is because we don't wanna break backwards compatibility. So especially, like, conversions between different types and things like that are are quite tricky for beginners, I would say. So one of the insights that I had was like, okay. We we don't wanna, like, really use all the features of the language. What we wanna expose to the users is, like, very simple API, which is essentially, like, the attributes that you kind of toggle to to some values. So, like, previously, I think if you use, like, Nick Shell and things like that, it's great.

12:10 But, like, you needed to know quite a bit of the language to kind of get things, like, wired up. So Devenv kind of, like, hides all that complexity away and kind of exposes this SIP. Like, I like to describe it as, like, a simple JSON language with, like, functions. Right? Because if you don't really dive into the dark corners, that's that's what you you know, we need a book, like, makes the good parts. Right? I think it's exactly the same as the JavaScript. So, like, that was the insight. Right? We wanna really dumb down the use of the

12:42 language and things that people need to do to in order to use to start with Next. Yeah. Because one of the the the main, like, complaints that you hear from people about Nicks is that, oh, it's you know, like, hard things are easy, but easy things are hard. And I think that this this part where easy things are hard is mostly the developer experience that is just been quite a quite a hard thing. So that's what we've been, like, really focusing on with Devenv and trying to, like, start from, like, pleasurable experience and then make it functional later. So

13:17 it's very controversial take on software. But, yeah, that's the the approach we took. Awesome. Well, I'm excited to dive into this. I think we should probably share my screen and dive into Devenv, show people how to get started, and explore some of those, you know, quirks of the language as we progress. Let's try it out. Yeah. Fingers crossed. So for anyone watching that does want to get started here, you can just go to devenv.sh, where everything that you need is there, including some samples of the language, the documentation, and again, the starter guide, which we're gonna kick

13:24 Getting Started: devenv.sh and Prerequisites

13:58 the tires on. So, normally, I would do the install, but I actually already have I mean, I'm running Nexus today just for this session, so that's kinda cheating. Right? But most people would have to have Next available on their system. As we've kinda covered, you know, it's available on Linux, Mac OS. So quite easy ish to get started, we're not gonna cover this. Now this is where I got tripped up when I first explored Devenv. So I'm hoping you can get a guide us on this part. Right? Is that to use Devenv, we actually have multiple options once Next is available on

14:00 Choosing Your Start: Devenv CLI vs Nix Flakes

14:38 our system. We can install the package into our environment using Next Shell, NextM, something like this. There's profiles and flakes, which are a completely different approach to doing it. Right? We can use the profile, but we could also use a flake.next. I'm still not entirely sure. Like, my next knowledge is very beginner. Right? I know enough to be dangerous and get a development environment up and running, but I don't really understand all of the the rest of the ecosystem at this point in time. So what I'm curious about, and I'm gonna try and give you a specific

15:08 question now instead of fluffing and waving my hands in the air. Right? But you know Next. You know Devenv. You built this tool. When you are starting a new project, do you go straight for a flake dot Next? Do you use a Devenv CLI tool? Do you do something else? Like, what do you do, and what would you encourage other people to do? Yeah. I I was I used to be, you know, a huge huge fan of and I still am a huge fan of of flakes because I think that the flakes solve a lot of the issues

15:37 with, like, handling dependencies and things like that. So that's where I would start, like, before I did Devenv. And then as I started to work on Devenv, I started to use it more and more because I kind of, you know, follow the Pareto rule of eighty, twenty percent, and I think 80% of the time, you want just the developer environment for your project. That's, like, most of what you need, I I think, when you are developing things. And because we've we've put so much work into Devenv, I think that it's it's a much simpler option.

16:13 So I now it's just I I would always go for Devenv. The only time where I would use Steelflakes is when you really need to, like, distribute software. Like, that's that's the part that Devenv doesn't do, at least at the moment. And and but, yeah, that's that's a different end topic. Like, what are the differences between Flakes and Devenv. But we yeah. I would use Devenv now for I mean, I'm obviously biased toward Devenv because I I created it. Like so if I say that, it doesn't mean that much. But it is like you know, I I still when I open

16:48 a project, I decide if I wanna use flakes or not. So it's yeah. Yeah. Yeah. I I was just curious, you know, what you would reach for. And I think for the audience as well that aren't gonna have as much experience with you and next. It's definitely the easiest way for them to get started as well. So let's go ahead and just make sure I have in my environment. Don't know why that Yeah. It needs this. Yeah. Now if you have flakes, this might complain, but let's see. This is, like, gonna show the the experience.

17:07 Initializing a Project: `devenv init`

17:27 Oh, you're using the z Zelly Jane or whatever is Yeah. It's such a good multiplexer. It's fantastic. Nice. I should try. So let's see if that will work. Ta da. Awesome. So install Devenv CLI, and then in order to create a new repository or add a Devenv to an existing project, I would guess, we could run Devenv in it. So I was gonna do this. Like, right right now, we're in an empty directory that has nothing in it. I mean, we could certainly do that and add some components and stuff, but maybe it would make more sense to

18:06 add this to an existing project. I don't know. What do you think? Yeah. I think, usually, you wanna you kind of have an idea of what developer environment you want to build for, you know, what's what source you have and and and, you know, what you you wanna, like I don't know. Let's say you have a Rust project. Right? So it's Let's do it let's do it this way. I mean, I'm not gonna put words in my audience's mouth. Right? But they're typically cloud native senior developers who are programming in Rust or Go. So I think if we can try and run

18:44 through two examples, the very simple Go program and the Rust program, I think that's gonna be of most value to the people that watch this video. Maybe I'm wrong, but I think that is our best bet for today. So let's start with Rust first because it's my go to language these days, and I'm gonna run Devenv in it, and then we'll take it from there. Now here's a a question. What language is Devenv written in? Yes. It's it's a good so first, when we create like, when I created Devenv, it was just, a glorified Bash script

19:21 because we were just trying to just, like, yeah, get the interface right and all that. Then I rewrote it to Python because I thought, okay. That would kind of, like, attract more people to contribute. You know, it's it's a much better language to to kind of, like, write common line interfaces. But then I rewrote it to Rust, actually. So some people were a bit like, woah. What the hell is going on? But what happened was I went to, like, something called what what was it called, Tiger Sprint, which was like a next hackathon of of about 20 people.

19:59 And, like, I was really happy. There was a friend who said, okay. I can, you know, I can teach you Rust pair programming. And I said, yeah. I wanted to learn Rust. So in a week, we rewrote Devenv in in Rust from Python. And I was like, okay. If if that's done in a week, then I'm happy. And and so now it's in Rust, which is which is actually not, like, completely arbitrary or just because Rust is cool. But it's also because there is a lot of tooling being written in Rust, so I think it's

20:30 nice that the community is approaching to to Rust or, you know, any language, really. But it is Rust, and and I think Rust is a great language. So that's one thing. The other one, there is Twigs, which is like a rewrite of of NICs in Rust, Twigs.dev. And I'm I'm kind of really excited about that. I I don't know how well it will go, but I think that it's it's super cool that well, first of all, we have an alternative implementation of NICs. And second of all, I think it's, you know, it's it's done with the right

21:03 foundations and things like that. So, potentially, we could integrate Wix at some point into Devenv, but that's, like, up in the air. Excellent. Yeah. Well, we have our first question, which is more related to the pronunciation of what I said, but Hain is saying that it rhymes with prestige. So I guess that's zelisch? Zelisch. Zelleys? I guess. Yeah. Alright. Yeah. Feel free to use the comment box, people. If you have any questions or you want Domin to answer anything, feel free just to drop it, and then we'll get to it as soon as possible. But for the moment, we have ran Devenv

21:12 Devenv File Structure Overview

21:42 in it, and we have a lock fail, a next fail, and a YAML fail. I'm gonna pop this open in Versus Code. All the random pop ups that I get. Oh, no. We are okay. These are just hidden stuff. Right? So Mhmm. What do you wanna look at first? YAML, Next? I usually always open Next first. And yeah. Alright. So what we have is some Next code that defines environment variables, packages, scripts, and some enter stuff. Do you wanna just kinda give us the the quick walk through of this this this kind of scaffolding? Yeah. So, like,

22:33 essentially, we have a bunch of called attribute sets, what we call in eggs, but they're kind of nested. So, for example, the first example is env, which is where you can define environment variables. So that's, like, very commonly used in the in the environments, like, either, you know, by there's also dot env inter dot env integration. So that's the most commonly used thing that, you know, you wanna store secrets and things like that, which will then populate the env attribute for you from from that dot env file. So that's, like, kind of the one of the basic

23:11 Exploring devenv.nix: Env, Packages, Scripts, Hooks

23:13 things, and the other one is the packages, so where you can define whatever packages you want to have available in your developer environment. And this all piggybacks on next packages. So whatever is available there is available also here. There's, like, Devenv search command, which kind of helps you to to search through the options and through the packages at the same time. So, like, if you wanna I don't know. If you type in, like, Postgres, you will see options from Devenv that you can set for Postgres well and and also the packages or and extensions and things like that that you

23:47 can set. And then there is, like, a bunch of other things like scripts, which essentially allows you to define different kind of scripts. You this is, like, by default batch, but now we've just recently added support that you can, like, write Python scripts or Rust scripts or whatever and just kind of inline them or even import them from another file or whatever. So that's I think that's kind of nice. So those are then available inside the the the environment. Then enter shell and enter test are kind of like two like, kind of usually, next, they would be

24:25 typically called hooks. So enter shell executes this bash code when you enter the environment, and enter test executes when you write Devenv test, which is like this glorified way of, okay. Set me up the environment, set up the processes, which I'm gonna mention a bit later, and everything, and then run this test. Right? So it's kinda like a functional testing or whatever you wanna call it, which is, I think, pretty cool feature that we added also quite recently. So maybe maybe this needs a bit of a different order now that I'm talking about it. But at the bottom, you can see there's,

25:04 like, languages that you can set, which is makes makes as a default as an example, but that we have about, I think, 51 or 52 languages right now, and it's super easy to add Numos. And then the the most exciting part, least for me, is, like, processes and services. So processes is just the way it is it's like a foreman profile kind of format where you just define, you know, whatever whatever command you wanna run inside your environment that is, a long running process. And then the services are, like, basically, obstruction on top of that. So, like like, Postgres,

25:41 you know, you it will run a Postgres process for you, but expose a bunch of a bunch of settings for you. So you can set, like, the initial database or where do you want Postgres to listen on the auth and things like that. Yep. And and I think there's also, like, about 30 of them, like, you know, Redis, different, like, mail, like, testing services and and and a lot of really commonly used, yeah, develop developer processes that you wanna have available that are common, like, besides your application server, for example. So you would define, like, application server stuff as

26:19 a process because it's, like, your thing, And then services are the the things that you usually kind of, like, piggyback on. And then I think, yeah, there's also pre commit hooks. I'm a huge fan of pre commit hooks. I think that they're, like, hated mostly because, actually, it's super hard to set them up. So, like, makes that makes that part super easy. Another one is that I think that people don't use them correctly. Like, you you wanna have pre commit hooks locally that just run on the files that you modified, and that should be, like, super quick. So when you

26:27 Pre-commit Hooks Discussion

26:53 commit something, it shouldn't take more than a second for them to run. So they kind of enforce, like, formatting and and and linting and things like that. But then the CI, here by default, if you enable any pre commit hook, will already automatically run as part of the Devenv test. So that is, like, kind of, like, the CI level where you want to enforce that everything is really, like, across the whole code base, like, formatted. And if it's not, then that that should kinda fail on your CI. So I I think that's I don't know.

27:27 I I really like them, and there's a lot of people using those. So I'm I'm really happy that to see that kind of adoption. Nice. Alright. There's a few things there I wanna touch on. The first one, I'll do pre commit hooks first just because that was the last thing you mentioned. I love the idea of Devenv automating that for me. The challenge I've always had is that every project that I do is in a mono repository, and the commit hooks are kinda globally scoped to that point. So I've never actually been able to get them work in a way

27:57 that as a jumper on service use. It only loads the hooks that I need for that service. So, yeah, I like the idea. I just haven't seen an execution that works for me personally yet. But then a lot of people aren't building in mono repositories for the moment. So maybe it's an an easy one for people that are watching. The other thing sorry. Do you have something to say there before I just waffle on for a bit longer? No. I'm I'm just curious about the use case. So, like, it's you you would like, so monorepo

28:14 Host's Use Case & Devenv's Value (Services, Cross-Platform)

28:26 okay. That means you have, like, kind of sub sub projects and you you would want, like, pre commit hooks defined per that third project. Right? Kind of like Yeah. I would need to take an EMVRC that unloaded the hooks as I jumped around and then only run them against that directory, which is probably quite tedious and cumbersome. But yeah. That there's just a way that everything I have is in one repository. My Rawkode Academy repository is all in there. Dozens dozens of services. That's interesting. I I yeah. We need to think about it. But Look. I'll open an issue, and we can

29:02 we could have a chat. Yeah. That's that's great. That's perfect. The the thing that drove me to Devenv is something that you also kind of, you know, I think you focused on and you're gonna run through this file, which is processes and services. Now the reason that that is what brought me over is that this is something I've done with containers since 2015. Right? So nearly ten years now. And I've written thousands. I've got tens of thousands of Docker Compose files in my life. And they've worked. Right? But there's no composition. I can't really define what Kafka or what

29:34 Redis, what MongoDB are, and then reuse them and consume them. And there are tools that that that try to solve this, but nothing's ever really worked. And I always found that I was rebuilding and reimplementing the same health checks over and over again and copying and pasting it from project to project. When I seen Devenv does this through, you know, services dot, you know, Kafka enable, etcetera, I was like, woah. That that is really cool. This is what we need. But more importantly than that is that container based workflows are really difficult for people that

30:04 aren't running on Linux because containers aren't native. On Windows and on Mac, there's virtual machines, and they've never really solved that fail syncing thing for hot reload to actually work effectively. And I think that this is why Next is probably gonna be gaining a lot more momentum, at least in the circles of in the people that I speak to over the last year, is that they need something that truly is cross platform that runs on Windows or Mac and Linux. And I don't know if Next does run on on Windows, but outside of WSL. Right? But it there

30:33 it certainly runs on Mac and it certainly runs on Linux And giving people an a development environment that is actually native to the host, I think is really important. And the fact that Devenv brings these services and processes across does make a lot of things easier. That that that is the sole thing that won me over. And I think we definitely need to show off some of the amazing things you can do with services and processes as part of our demo team. But I know I just get a waffle there, but I think it's so important. I think it

31:00 just makes life so much easier for so many people or can make life so much easier for so many people. Oh, yeah. For sure. So, like, what what's really interesting is that, like, one of the major users of Devenv right now from, like, my, like, how to say, nonstatistical assessment is that there's a lot of PHP users, actually. And that is because they they have a lot of knobs to churn. For example, debug. Like, they they turn some PHP stuff with debug on and sometimes not. And a lot of these container based Docker style builds, they just don't compose. Right? So as

31:42 soon as they saw the dev can can allow them to, like, quickly switch versions, enable debug for different processes and things like that, they were like, okay. That was immediate sell. And then on top of the fact that Docker is super slow on Mac OS, so a lot of developers, like, needs like, it's a huge penalty for them, that fact that it runs natively. Yep. Those two things just was an instant sell, and and there's, like, really a lot of PHP developers. Yeah. And it's not just it's any it's not just PHP. It's any interpreted language. We're

32:12 talking about Python, Ruby, PHP. You know. These large projects have tens of thousands of files, and syncing them to a VM is never gonna really ever be fast. I know they're trying, but it's been ten years and it's not been a solved problem yet. So, yeah, all of these people have a lot of benefits from just running that Devenv and then getting started with a local environment. Now let's get back to actually making this do something. Let's try. Yeah. So we said this is gonna be a Rust project. I'm assuming well, I do have cargo.

32:34 Adding Language Support (Rust Example)

32:48 I can't remove cargo. Right? That's just something I've got. That was it rebuilding my system. And let's just get a local cargo. I don't even know how I'm gonna be able to kinda show that. Right? Because this is my next profile cargo. Mhmm. So let's just change in fact, let's leave next because I'm curious about what we can what that we'll show people. Let's just do Rust enable. Mhmm. And if I just hit return, this is automatically going to reload and augment my environment because we have the ENVRC here, which tells it to use Devenv as part of our process.

33:12 Devenv's Default Tooling & Philosophy

33:27 Right? Mhmm. Just by me hitting return, running any command, c d ing out and into this directory, we can now see that it is fetching next stuff and eventually rust stuff to give us a the tools that we need to successfully run and instantiate this project. Now while that runs, maybe you could give us a little bit of information on, you know, when I enable next, enable Rust, what is Devenv? What is it establishing? What is it doing for me? Yeah. So, like, a a lot of times when you develop for a specific language, you kind of

33:59 need to look up, you know, what compiler do I need, what, like like, debugger do I need, maybe, you know, some profiling tools, language server support, things like that. So Devenv has this philosophy of kind of enabling all of that by default. So it's, like, not full batteries in terms of, like, everything everything, but it tries to to kind of balance that out and says that, like, anything that you would potentially, 80% of the time use, we kind of enable it. And then you have knobs to potentially disable that if you need to. But, like, I think

34:34 yeah. This is, a design choice. Right? Either you go super minimal and then you have to enable each thing. But I think, like, downloading those few megabytes of each tool is, like, quite not a big price to pay. I mean, at least us, we're privileged to live in fiber optics or or good Internet, but, hopefully, everyone will be at that you know, is going towards that in the world. So I think that that's kinda like the design philosophy. And and we are, like, trying to for example, right now, Krishna is working on adding language support. So, like, you will be able

35:04 Customizing Language Options

35:11 to get language sorry, language server support. So you will get for each language already that preconfigured and, you know, your editor just picks it up and things like that. So, yeah, that's, like, the simple then in for example, in Rust case, you have a bunch of options. You can pick, you know, the tar you can set the targets. You'd be like I don't know. You wanna target WASM. We we do that. You wanna, like, pick a different channel. Let's say you want Nike Rust. Right? We we have support for that. So you can kind of, like, tweak your

35:45 way into how you want that to be from our defaults that we provide. Yeah. So let's dive into that a little bit. No. I don't have fiber at my new office yet. I am waiting very patiently. Have to make my It's quite a lot. But if we go to this languages page, for a start, it just lists everything. But if we wanna find the options for languages, this is gonna take us to here. Mhmm. So if people do want to tweak and configure what they get, we can scroll down. Let's find the Rust example. Quite a lot of PHP stuff there, actually.

36:22 Maybe we should've done that. But let's find Rust. So we can have enable. We can change the channel as you said. We can add components. So by default, we're actually getting the compiler. We're getting cargo, clippy, Rust format, and Rust analyzer, which is fantastic. And then there's Rust flags, molds, targets, etcetera. So, yeah, everything that people need to be able to tweak and configure the way this this language support works, you could just come to this page and even just go through to the source if you wanna take a look at the next that makes this happen. And this is

36:55 one of the things that I thought was amazing when I stumbled across Devenv and started using it. Is that, like, 90% of it is just next code too. Right? Like, if we go to the the homepage, it's like, yeah, you got your 20% Rust, but most of this is just next code that facilitates that. I I don't know if it's templating or spec or whatever, but yeah. So this is a good way for people to get familiar with Next by taking a look at the components, languages, processes, and services that you provide I support. Yeah. That's the beauty of next. It it

37:27 really does. So, like, Devenv, the way I say it is, like, we took our expertise of how you should set up things and we kind of, like, obstructed that away. Right? Which is the main pain point of many people who came to Nick's. Was like, oh my god. It's it's difficult to to pull everything together, and you need to be a Nick's expert. And it's like, no. It doesn't have to be that way. Right? It's just about a pattern called convention over configuration, which is, like, you know, by default, you get a really good set of things, and

37:56 then you kind of configure your way into your desired path, right, rather than you get a blank slate and then, you know, you need to build everything yourself. So, like, in the past, you know, the way I see it, there was a lot of early adopters of NICs, like me, who were super enthusiastic to hack their way through. But now people just they don't wanna learn NICs. Right? What they want is, like, a developer environment and do their work. So this is where this is kind of, like, the gap that I see we're trying to fill in here.

38:27 Nice. Alright. Well, my Internet caught up. And if I run which cargo again, we now have a next store path for the Devenv version of this. And I just wanna kinda highlight this. If if I jump out from Which Cargo, we go back to the original. And if I jump back in, we go back to the store. So I love this loading, unloading as I move around, and I'm only getting the tools for this project that I need. Sweet. So let's get some Rust code. Cargo in it. And let's see. We have hello world. Now

38:28 dir-env for Seamless Environment Loading

39:14 we could just use Cargo. Right? We could do our build. We could run the project, but we wanna lean into more Devenv features. So, again, in your experience and and what you do, what what's your next steps? How are we looking at and bringing in more of Devenv's convenience to people as they adopt in their project? Yeah. So I think it would be two parts. One is, like, you would configure Rust. Let's say you want to use mightly channel because, you know, you're using some some features from from there. So you would first, like, explore what what options we support for

39:48 for us or, you know, even add like, it's quite easy to add, like, new new configurations options. Well, that's a bit advanced, so that's maybe later on. But the the second part would be to define the processes. You know? Like, usually like, a simple way to is just a simple watch. You know? Watch this directory for changes. Like, you can add, like there's, like, a ton of watcher programs. And then when something changes, execute something. Right? That's, a very simple process that Yeah. I don't know. For example, you have Tailwind and you want compile CSS. Right? So every

40:26 time that Tailwind file changes, you compile the CSS. Or, like, you would run a cargo watch, for example, right, in as a process as a development process. That those would be the first two steps, I think. And then the the third one would be the pre commit hooks, in my opinion, is to to, like, enable clippy, enable, you know, format Rust format or and things like that. Okay. Let's try and go through each of those one at a time. So right now, let's try and set up the cargo watch. So every time I change my main to

41:02 Defining Processes and Services (Adding cargo watch, enabling Postgres, Temporal)

41:03 r s, it's gonna recompile our project for us. I think that would be a good step. So is this something we're gonna add to to enter shell? Do we do a different way? How would you set that up? The cargo watch, I would just add it to at the top when you have processes. So maybe sorry. At the bottom. Oh, yes. Left, right. Yeah. So I don't know. Here, you just pick a name you want, like cargo watch and here. And I I don't think cargo ships the watch by default, does it? Oh, it doesn't?

41:37 Okay. Oh, it yeah. So we have to add that as a package, don't we? Uh-huh. Okay. That's a I have no idea how that's done. I guess packages dot cargo minus watch would be my Yeah. Let's see. I think you just yeah. There is legacy packages. Yeah. I think you just Is it gonna be, like, a cargo Cargo minus watch. Packages? It should No. I think just cargo minus watch should be. Okay. I don't know if that works well together, but probably it does. Let's try. I have to admit that I I don't I don't use because I have language server

42:29 support in my editor, so I I usually don't use it. Alright. So what we've done here, added the package that we need, created a process. Now processes are only executed when we spin up the development environment. Is that correct? Mhmm. Yeah. This is like the run processes command kind of work, which is heavily inspired by the the proc file. Alright. So what you see here is is some a project called, process compose, which I found is one of the best tools for this, like, kind of development environments processes preview. So at the top, you just see

43:16 a list of processes that you can click. I mean, now we have only one, so there's not much to to go. But then as you kinda switch up and down or whatever or with with the mouse, then you at the bottom, the locks kind of change so you can kind of see locks for each process. And you can, like, control r to restart it and things like that. So it's it's really convenient. Takes a bit of learning as any tool, but I found it's the best one. You can also turn on different ones like Overmind,

43:44 which I think is like a TMax based or Honcho, which is like a implementation of Foreman. And, potentially, any can be implemented as a way to to run this. Nice. But, yeah, this is a good default one. Make a change. Say hello world with two exclamation marks, and there we go. We get our thing running in the background. So that's pretty neat. Nice easy way to get started adding a custom process. But it's not just custom processes. Right? If we come back to our devhunt.next, we have these kind of not managed, but provided services. Exactly. Yeah. So So here you see the

44:28 the full list of what's currently supported. Yeah. I mean, the fact that temporal is here, I have struggled many times to set up temporal development environments. And for Devenv, it's a one lane flag, which is great. So Yeah. So it's you know, each of this is a lot of time spared for yeah. And even, like, you know, I I like that like, you know, if you use Docker, you always have this paradox of choice. Right? You wanna run Postgres or, you know, whatever, and then you go to Docker Hub, and now you need to pick which one you want to run.

45:06 I mean, this is getting better by by creating more official ones, but I I find that it's nice here. You just have one, and that's it. Yeah. But even with the official ones, you still have to learn what environment variables you need. You have to work out the liveness probes and all of that, and there's none of that that is specifically needed here. So let's just enable this one. I'm trying not to pull down too much with my 50 meg connection at the moment, but let's try to be Postgres and Temporal. And for this, I'm just going to do

45:39 quit, and it's already reevaluating my environment. And here we go. Alright. It's not too bad. Yeah. It shouldn't take too long. Well, that does that. I guess we could add a well, we've got shells and we've got tests. Right? So Mhmm. And we've this custom script here. So this would be another cool thing to show people, I think. Let's add a script to build our project. Mhmm. Build. Exact. And this could just be cargo build. And then and the shell, we can just, yeah, we can just do something something like this. Here, into test, you could run cargo test,

45:56 Defining and Running Custom Scripts (`devenv script`)

46:26 for example. Right? That would be Yeah. I mean, it should tell us we have, you know, zero tests, but that's okay. Yeah. I mean yeah. And let's just add an emoji because everything is better with an emoji. Right? So I actually don't know how to type emojis on my Linux machine. On Mac, I use Raycast, but I don't think I have anything configured for that here. So we're going old school. Okay. So let's just reload this one more time. We have an enter key. This will set up our new script, our enter shell, and our enter test, plus we could take

46:59 a look at the new services we now have available. So let's start with the scripts. We added one called build. This is just a convenience layer, right, to the point where people could just execute any of those script names and it runs the command for them. Mhmm. As far as again, I wanna dive into, like, your experience. Right? This is you've been doing this for a long time now. It's very easy for people to reach for, like, a just file or a make file. Do you see these scripts as, an alternate alternative to that? And I mean, that's through

47:37 composition. Like, if I run build, can it do multiple steps? Or should people still reach for adjust file or make fail? Like, how do you see that working now and and the future? Mhmm. I I think that the scripts are quite powerful. So you because in Snakes, you can substitute a lot of things inside. Right? So you have a programming language, so you can kind of reuse snippets and things like that. So, like, even even if you would, like, have things that depend on each other, you you could kind of abuse them to, like, just,

48:10 you know, like, inline the scripts if you have, like, one thing and then the other should run. So you could have, like, build and then tests, and then inside test, it runs the build. So you can do quite a lot. But I think once you really once it really gets complex, then probably you should reach out for for more framework y approach. I don't know. Just file, make file, whatever is your favorite one. But I think that you can get quite far with this one. So, yeah, here here, you need to do config dot scripts. So this is like config

48:44 is a special thing. It's like, essentially, you're referencing the the the environment you're configuring. So, like, this Devenv definition is essentially a function where at the top, if you go to the very top, it's like a function of of a few arguments. And what's it's returning is config, but you also get this config as an input. So you can reference things as you define them. So the the tricky bit, of course, is you can create infinite recursion if you would reference the config now in the build part of the scripts. That would get into some horrible error messages.

49:20 So that's probably the hardest bit of mix Yeah. If you kind of get those recursion errors. But, like like, yeah, if you have to to just get the intuition about this that you are, like, referencing the what you're returning. But it's really neat, right, that you can do this. Yeah. I mean, would you welcome a pull request that loop like dependencies? Like, I know this is not doesn't really make sense, but, I mean, something like that could probably be quite a good approach as well. Yeah. Exactly. Yeah. I I I like that because this is exactly the,

49:57 like, the mindset behind Devenv is not to use these advanced next features, but but, like, dump them down exactly in what you're saying. So that's that's a good one. Yeah. I think I mean, I yeah. I could write a just file, and I can just execute them within file. That's that's a perfectly good way to do it. And I think a lot of people would probably do that. But as I lean more into Devenv, I wanna do more stuff that that way. So yeah. There's something just for me to think about in the future. Anyway,

50:23 let's pop back over here. So we added our scripts. I'm gonna run that publish one just because I I didn't know you could do that interpolation within the the script itself. That's pretty neat. So if I do publish, yeah, we're build in the publishing. Awesome. We also did Shell test and services. So we've already seen Devenvap, so let's run it again. And we should see that we now have a process composed with multiple processes running. And we can show people that switching between the processes to see the logs and see what's happening. So there's our cargo check.

50:56 Our Postgres is currently spinning up. It's not quite ready yet. Our temporal is already on the way and quite happy. I love that. It's so powerful. And now Postgres is ready as well. So It's pretty crazy how simple it is. Right? I don't know. It makes me smile each time. Yeah. Three lines of code. Like, unbelievable. I mean, think of how much that would take in a Docker compose just because YAML doesn't have that level of composition and remote packages and all this other wonderful feature. I absolutely love that. Cool. If that doesn't win people over, nothing will.

51:34 So Exactly. You drop it off now, you know. My fault. Alright. Let's quit this. So there we go. And the last thing that we've shown so far is the Devenv shell. Am I already in a shell? Yeah. So because you're using the dir enf, which is like this tool that you're using that when you just enter it, kind of, behind the scenes, enables the shell. Yeah. So if we just pop out and then pop back into Rust and what we're looking for is that we should see this run entering shell and get version, which we have here.

51:35 `devenv shell` and `devenv test`

52:15 That's a neat feature. And the last one was our dev and test. Yeah. So I think this is another thing that is not well known and and kind of new, but I found this I find this really, like, really nice feature. I don't know what's happened now. But, yeah, the the fact that you can run things with the whole environment enabled locally, I think that's quite unique. Yeah. So our test ran and they're successful. It's just all the the process noise in the background. Oh, yeah. This is, like, shutting down, like, errors. So yeah. I wonder if you can hide

53:06 those. Maybe maybe we need to improve the the output there a bit because it's a bit in because, like, what we're doing is, like, we are running the processes, piping that to a standard output, and then also whatever the test is running. So that can be a bit confusing. Yeah. There's definitely a flag that hey. The surface logs would be Yeah. But regardless, that is some serious amount of power, I guess. Right? And convenience. Mhmm. But convenience more than power. Think that's the word I'm looking for. And again, we're at 54 lanes. Most of that was provided to scaffolding

53:45 for us, and we've had to change so very little, but and return. Right? We've put little in and we're getting a whole bang for our buck back. And I think that is just the true now it's the right word power of Devenv. So I think that's amazing. Such a great product. Wow. Now I'll encourage the audience. Anything you want to see or ask, now would be a great time to throw that into the comments. And, Dom, and I'll ask you, is there anything of Devenv that we haven't covered that you think would be really cool to show the audience? I know we

54:17 said we're gonna do a cool example. We we we could do that too, but I think probably showing off this Rust one demonstrates everything that we need people to know about Devenv. Right? Yeah. I think the the last missing bit is, like, people often ask how do I how do I then deploy? Right? Because I want to I wanna have the same environment potentially also in production. So Devenv, like, ships with kind of a a way to generate a container out of the development environment. So there is, like, Devenv container builds, Devenv container copies so you can, like,

54:30 Building Containers for Deployment

54:54 copy it to a registry or even Rawk, which kind of just runs Docker Docker in the background at the moment, but that could be improved much further, I think. So, like, you can take this environment and and then, like, ship a container. And there's also a flag, like, container like, config dot container dot is building so you can kind of conditionalize things based on if you're building a container, or are you are you just, you know, entering a developer environment? So for example, let's say you have, like, a a managed Postgres. Right? Then you instead of enable

55:33 like, services Postgres enable, you would say instead of true, you would say then config dot container dot is building well, exclamation mark. Right? So you want to negate that. And then I think that's pretty neat. Right? So you're you're Yeah. You're then, like, conditionalizing how what goes into container and what goes into your developer environment. Nice. And there's so there's, like, a few different con like, I think there's two containers that are provided by default, but you can create your own. One is just a simple shell. So if you say container oh, dev dev container

56:12 build shell, that will build only the the shell. So let's say that's something that you would ship. Oh, I don't have Docker. Oh, you don't yeah. But I I think if you just do builds, you don't you shouldn't need Docker. Or do you no. You do need Docker. Yeah. But yeah. I think, yeah, here it's asking you at the bottom to to like, it needs a few dependencies. So you need to, like Ah, right. Okay. Yeah. Like, enable so next to container is a really nice project. Oh oh, Nick's packages. I didn't copy it. Yes.

56:57 Yeah. There we go. We should probably have No. That was me. I think that was that was my terrible copy of the pasting. So Yeah. Yep. So now you right. So now it wants you to set a name. So, like, unfortunately, yeah, that's not the best two weeks, but you can either set the name for the whole project or for the container. But Yeah. Yeah. For example. And I think it's gonna ask you for one more yeah. So one more thing. Now you need to to enable this one. Yeah. That's something that we need to improve

57:37 the UX like you if you if you need, like, two dependencies, we should be able to tell you that in one go. But Yeah. But even at that, the fact that I am now building a container from this is pretty sweet. I thought I I actually had no idea that was something I could do. So Yeah. So, like really leads me into getting no. It's all great to have a development environment. Been able to get something into production is a different story, and I I just completely missed this. So that's very, very cool. Awesome. Yeah. We have an example for fly.io

58:10 where you just, like, configure their registry and, like, you can then push these things to to fly.io, for example. So it's very easy to go from developer environment into production then. Oh, so is that where where does that live now? Test container. So, yeah, that's that's that's now part of the department. No. Wait. If you just do build, that doesn't that doesn't, like, copy anywhere. I think that's just built it. That's it. Ah, alright. Alright. Okay. Okay. It's more like if you wanna have it as part of the CI or something. But then if you wanna do something with

58:55 it, you need to either copy it or run it. Those are the two things we support right now. So, like Okay. Copy. Let's see what the help says. That just puts a name. I'm gonna call it test. Yeah. So by default, it's gonna copy to to your local Docker if you have one. Cool. Alright. Let's let that finish. So I've got a question from my point of view, but there's a couple of things on the chat or at least one thing in the chat we'll cover as well. So firstly, just says heart. So I'm assuming you're enjoying what

59:00 Copying Containers and SBOMs Discussion

59:33 you see, which is amazing. And then is back with it would be I'll I'll just gonna put words in your mouth. It would be good if an s bomb could be created with the container and bundled together. Is that something that you just thought about or considered? Yeah. So at actually, there's quite a few projects that do create SBOMs, and you we have the whole, like, next store closure as it's called. So that should be possible to do. I haven't I haven't I didn't dive into this that much to to be honest because just it hasn't been,

1:00:11 like, the forefront of what our customers are using asking for. But, yeah, it would be pretty neat. I agree. Like, for me, the SBOMs, it's always like, then what do I do with that? Right? I it feels like the ecosystem is really huge. So I'm I'm not familiar with with with the ecosystem yet. I I just need to dive into it is what I'm trying to say. Nice. But, yeah, should be very doable. Why did It doesn't matter if it doesn't work. Maybe it's ran ran out of disk space or something like this. It's a

1:00:50 bit like, the error messages that you get from the Docker daemon are a bit weird. It's super yeah. It just says, like, okay. Closed pipe, right, which means that it lost connection to the daemon, then sometimes you need to then read the Docker daemon logs. So I I don't have I'm using Podman. I don't know if that's been tested. I I know they're closely compatible, but may not they may not be byte for byte compatible, especially doing something like this. It could just be my setup, but we'll give that a moment. Yeah. K. Let's Yeah. So clear the screen. It's

1:01:26 a 10 gigabyte file. So, like, one of the, yeah, one of the things that we need to do still is, like, dive a bit into the closure size for the containers right now because we have this mentality of pulling everything in for the developer environments, then that doesn't work really well for production as in that the image that you're copying can be quite big. But you can disable things. Right? So it's you can get there. Maybe maybe in the future, we'll introduce something like profiles where you will say, like, development for profile and you get, like, the full blown thing and then

1:02:01 production where you get, like, just the basics or, yeah, minimal or whatever it would should be called. Awesome. Alright. So it seems there's no more audience questions, which means you're gonna be stuck with one of my harder questions, unfortunately. That's perfect. Right. So one of the things again, this comes back to my mono repository use case. And I know that Devenv has some layers of competition. So I'm curious if there's a challenge that I have right now that could be solved using Devenv. Mhmm. Let's assume we have a second Devenv project which has Mhmm. Proto buff files.

1:02:10 Advanced Topic: Monorepo Artifact Sharing

1:02:35 And it has a build step that compiles those. It has an output directory. Mhmm. If I want to consume that output directory from a different Devenv, is that something I can do now or in the future? So you would want to reference those prototype of, like, output. Right? The Yeah. Let let's put a really quick example with that go directory whenever you use. Right? So if I do dev end in it. Mhmm. And let's just open both of these at the same time. And I do apologize if this is a tough question, but I'm just No. No. It's

1:03:07 a great question. I like that, you know, real use cases pop up. Yeah. Alright. So this isn't obviously not a good thing, but if we pop this open and just say that my build command creates a file. Now it doesn't matter. That could be protobufs. It could be anything, but it creates this artifact called a Mhmm. And the a directory. So now here, I can see dev in fact, I can just run my build step once I reload my environment. Oh, out there. But Oh, yeah. You need to create a. Yeah. So now this project has

1:03:54 had some sort of artifact. But it could be a pro buff compilation. It could be binary from a cargo build. It could be as typescript code generated from GraphQL schemas, anything. But now instead of my Rust project, I want to consume this out a file. Is that something that Devenv can help me with? Yeah. So the short answer is no. But right now, you cannot really do that. The longer answer is that, like, one of the one of the kind of, like, vision for Devenv is that, like, right now, you you can just kind of bring in the

1:04:36 tools, like, the the the packages, the tooling, the the the processes, and things like that. But, like, the longer term vision is that you you will be able to upgrade to your whole project, right, so that you can say, okay. I have a Rust project. Now build it the whole thing with Next, right, which means that, like, your project is built and converted into mix derivations. So it's built, like, with sandboxing on and everything like that. And then once you you would be able to to do those things, then that the result of that build is

1:05:10 actually your artifact, and that you would be able to kind of compose those those things together. But that's that's of a, like, longer term because I think right now we're focusing on just creating the environments because I think that's where people should get started with Mix. And then Mixifying your project is usually not a trivial thing, at at least at the moment with the tooling. But that is, like, a lot a lot more work to get there and to help people with that. Okay. So the only way to do that could be for the Go project to be

1:05:43 its own next derivation and then consume it that way. Yeah. So that that's like a future work for Yeah. I think if Devenv could abstract that away so that I don't need to go deeper into next, that would be phenomenal. But Yeah. That's that's the goal that you would you would, like, say, I don't know, languages.go.mixify or whatever. I don't know how it will exactly look. And then it will do its best that you don't have to do much. But there are cases where you need to override things because Nix cannot, like, infer everything it needs, but, you know, by itself.

1:06:22 So that's that's where it gets tricky. Awesome. Alright. Well, thank you so much for spending time with me today. I always finish with the same question. It's like, are you happy to share a bit about the the road map? Right? What is next for the Devenv project over the next three, six, or nine months? What are you just gonna be tackling next to make people's lives a little bit easier? Yeah. So right now, we're we're just going through, like, issues people report and trying to to not stabilize it because I think it's pretty stable, but, like,

1:06:34 Devenv Roadmap (Future Plans)

1:06:57 to squeeze out all the the bugs, all the edge cases because it's such a general tool of setting up all the languages, processes. There is quite a lot that people do with it Yeah. Which is really exciting, but we are trying to to kind of go through that. And then the second thing we're we're looking into is, like, kind of reimagining how CI would work with with the with the Devenv. And and because, like, what I like about Devenv is, like, a local first tool, and then I think that's a better default than a lot of the CIs today is where, like,

1:07:34 you you first use this, like, arbitrary proprietary stuff, and then locally, you cannot really replicate that. So we're, yeah, we're looking into end of like, experimenting with with that because I think it would be pretty neat to have a clean developer environment built from scratch, and then that is your CI where and where everything runs. Yeah. That's pretty much it. Like, Devenv integrates already with Cacheck, so, like, you get already a lot of those features out of the box. So that's already done. Yeah. That's about it. We have another project that I don't want to

1:08:12 to to to mention mostly because I don't want us others to copy us yet. Once we release it, others are feel free to copy. But I I I'm really excited about that one as well, unfortunately. I know I'm super vague, but, yeah, it's gonna come out sooner than later. Right. Well, people can always watch this space, and I'll finish with, you know, the Devenv as an open source project. You can find that at github.com/casix/devenv. I'm assuming your new product is gonna be launching soon. We'll also be available there so people can check out the organization,

1:08:32 Conclusion and Resources

1:08:45 keep an eye on things. And, of course, we'll be sure to get tweets and things out once it does launch. Any last words, Domin? I don't know. I just wanna thank you for for this. It was really great. It's always great to to see, you know, that you how you how you would use it and the trial we we found a few nice little things that we can improve on the way, and that's really valuable. So, yeah, thank you so much for for this. It was great for me. I hope that people enjoyed it as well. Yeah. Again,

1:09:14 thank you. It's always makes my day when I get to sit down and, you know, show off a product that I generally love using. And I hope that other people are watching this and go check it out too. So thank you again for your time. Thank you everyone for watching. We'll see you all again next time. Have a great weekend. And, yeah, we'll see you soon. Thank you. Thank you for watching Rawkode Live.