Gergő Móricz | Algora TV

My contributions to Cal.com, Tailcall, Mendable, and more...

Gergő Móricz

Rust

TypeScript

Other

Watching now

Bounties collected

OSS projects contributed

amitksingh1490: You can try this

amitksingh1490: https://www.pulumi.com/registry/packages/aws/api-docs/lambda/function/

amitksingh1490: better dx than tf

McPizza0: epic session

McPizza0: really enjoyed hearing what you've been up to

amitksingh1490: Great session

zaf: you're a rockstar gergő 🔥

McPizza0: how can maintainers make it easier for you to dive in?

mogery: already ended it on my side, but that's a great question! devcontainer/codespaces support is a must for diving in

mogery: my bad for reading your username wrong :D

McPizza0: would something like a codebase walkthrough video be helpful?

McPizza0: or deep dive dev docs?

McPizza0: Haha, no worries

McPizza0: we can continue on discord too

mogery: i think just a project layout in CONTRIBUTING.md is peak

mogery: or even like a flowchart

mogery: you can do very nice ones with GitHub's built in mermaid rendering

mogery: if you have like an end-to-end flowchart that makes it really easy to understand

mogery: but it's also a high-investment thing

McPizza0: do you have any good examples?

mogery: just written project structure docs is the sweet spot i think

mogery: lemme find you some, i have some internal ones from a project but i'm not sure i can share that

McPizza0: ok, great!

McPizza0: send me a message on discord if you find any

mogery: will do! ty for sticking around

mogery: <b>test</b>

02:58 Alright, hello everybody and welcome to the very first edition of Mogery's code sesh!

03:26 I am Gergő also known as Mogery and we are live on Algora to discuss my contributions

03:35 to the open source projects that I've done throughout Algora and also how I got started what my setup is like and basically my thoughts on how someone can succeed

03:48 as a developer on Algora. So let's jump right in. So this is my profile. I have done a

04:00 I have done a couple of bounties.

04:04 Most of them have been with three projects, so I did the first one at Cal.com.

04:11 That's really what got me started with doing I go right in the first place.

04:17 And then I've revert on two different types of bounties and the difference between these makes them really interesting but

04:28 we are going to talk about this later so the very first thing was the scow.com issue

04:39 it was ICS feed support for checking against double bookings.

04:48 So, Cal.com is a scheduling website, basically you get a link.

04:55 And if you send that link to anyone, then they can schedule an event in your calendar.

05:01 It's super clean, super useful. A lot of people use it. I like it personally.

05:07 And it's really just a great product and they are also open source.

05:20 So this issue was opened about ICS feed support.

05:28 So you have a lot of different kind of informats or ways

05:34 to grab kind of their events.

05:37 So you have CalDAV, which is sort of like a hosted

05:42 the common managed server thing.

05:45 And you also have a raw ICS feed that just contains

05:49 calendar events and you can parse them and do stuff with them.

05:53 So as well as like more managed integrations,

05:58 like Google Calendar, Cal.com also supported CalDAV,

06:03 which that's anyone connected to a calendar server,

06:05 but did not support ICS feeds. Now the thing is that these two are kind of similar.

06:18 So it was kind of easy to add this and instruct me as a good first issue potentially

06:28 So I took a look at this issue one thing that you may notice is that this is actually really old

06:33 So this was on Algora for a while before I came across it and

06:40 and yeah so it was added to Algora on the nice of October and I came across it in January of this year.

07:07 So January 17th, I started my attempt.

07:10 And I was really a bit varied because it's not really easy

07:18 to get accustomed to a new codebase that you are working on.

07:24 So that was something that I especially wanted to

07:28 sort of develop in myself that scale to adapt to different code bases. But also more of a

07:34 technical issue was to actually get capital Cone set up and running online machine. So

07:40 line machine. So I was just browsing their readme file about the development stuff and I saw

07:54 that they had something called a Gitbot setup and this actually came really in clutch. So what GitPod does is you can nomin with GitHub and you can create a workspace of a GitHub repository.

08:12 You can say, okay, yeah, we have code, it's fine. You have sort of has everything installed that you need to run a project.

08:30 It's really cool. I can actually do okay. Yeah allow. So if we take a bit here it's going to install an extension and it's going to open but that's not really what I'm concerned about right now.

08:46 So not every repo has this but especially if they have this or if they have gethup code spaces

08:54 integration that is a really really good way to just immediately jump into a project.

09:00 jump into a project. So this is what I used for the first time and then I actually went

09:08 on to build my own solution for being able to do this with other projects that may not have

09:15 this setup but let's talk about that later. So if you take a look at my PR here, this was not really something that was super difficult.

09:27 I find remember Craig neat, I did this in an evening.

09:32 I actually took a bit to get around to it, but it was, I would come home after school and just

09:39 take away on this and then I eventually open this PR. So if you take a look at this, the main thing that I did was I had to sort of look at how

09:51 apps working in Cal.com where they are set up.

09:54 They actually have some super useful tooling that will generate apps for you, but it's not

09:58 really well rounded or something that it cannot do. So I did have to actually take a look at what's going on in order to find everything that I needed to get this set up.

10:10 So what I did basically is I knew that their CalDive app was very similar to this one,

10:16 so I just searched for it in the code base and I saw, okay, it's there and it's here and it's there. So I tried to replicate its behavior with my new ICS feed app.

10:29 And the whole ICS feed kind of their API is also based on the CalDAV API.

10:36 So a lot of this stuff, especially this ICL parsing is just taken from the CalDev code

10:46 because I was able to recycle it really quickly.

10:49 Of course, it's not ideal to copy-paste code,

10:52 but it wasn't really like compartmentalized.

10:56 Anywhere that I could just call into it.

10:59 So I didn't have to duplicate this code unfortunately,

11:02 but it did work and everything's fine.

11:08 So, yeah, I added this app. I did a little bit of testing, a little bit of UI.

11:15 I had to do 40 actual setup page that the app goes through.

11:20 So, yeah, and then we also have an SVG icon that I have to make.

11:29 This is also based on the CalDev icon.

11:32 It is basically the same icon, but it's said CalDev instead of ICS here.

11:38 So, what I did is I just opened Inxcape and replaced CalDev with ICS.

11:40 just open in-scape and replace CalNet with ICS.

11:46 But yeah, so this is something that struck me as a good first issue.

11:52 Not only because it was kind of trivial with the pre-existing functionality,

11:59 but also because it was a good opportunity to practice getting into a code base.

12:06 So that's really what's from me about it.

12:10 I did, of course, have to have like pre-existing knowledge that, oh, okay, because it uses

12:17 CalDAV.

12:18 It's probably easy because it already has I Cal, but of course, if you know different things, then you can apply this to different projects and you can be successful there. So this was something that was I was pretty comfortable with.

12:34 I've used iCal before I've used basically everything in the text stack of cout.com. So that's what

12:42 really struck me. As okay if I'm going to start with

12:46 something I need to start with this, it's been a long sending issue, it hasn't been touched in a

12:51 long, long time. If I fix this, some people are going to be really happy about it, which is always cool. And yeah. So this got merged. This was probably the easiest or one of the most easy merge processes

13:10 that I've had on Algora. I don't really have to chase maintainers for this one. They just

13:17 pulled it in one time. It came very cool. So yeah, that's basically it about this and just the ability to open this get pod and

13:28 not actually have to install everything on my local machine and the clutter everything up.

13:34 That's really what made me sure that I need to set something up like this.

13:40 need to set something up like this. So after I did this I actually started researching ways

13:50 to create a workspace, something like you get a workspace but I'm sorry code space but

13:57 locally because I have a big tower PC that I mainly used for gaming and I'm really using anymore because

14:05 I don't game that much anymore.

14:08 But I had the resources so that I wouldn't need to rent it.

14:13 And basically what I ended up doing is I found this project called Coder.

14:18 And it lets you set up these deployment templates of like Docker containers, Node containers, so these are

14:26 development containers. So what these containers do is that you have a terraform

14:31 file here that sort of sets up stuff. This is not really important, but you have something called

14:40 a Jesus Christ. What is this music? Give me a second.

14:49 Okay. So yeah, you have this third form file.

15:01 Give me a second here. My included is overloaded. I'm going to use the server file.

15:05 You have this Terraform file that defines like, okay,

15:10 create this Docker container.

15:12 Create this Docker container.

15:18 Create these like install these Docker file and run this launch script.

15:25 And what you can do with that is you can create sort of deterministic

15:30 developer environments.

15:33 And you can recreate them and spin them up really easily.

15:39 So, yeah, that allows you to create some of these disposable dev machines that you can

15:47 install everything on and mess up without actually affecting your main machine.

15:53 So I like to code on my laptop.

15:57 It is a M1 MacBook Air with 8GB of RAM.

16:03 So it's not bad, but it's not a super capable machine.

16:09 So my solution for that was to set up this

16:20 Docker container that you have, but I created a Rust environment, a Node container, so that

16:27 you just spin one of these up and start developing instantly. So you can see all the

16:33 Mendable stuff I did is in the container, all the Tailcall stuff I did is in the container,

16:38 there's also quadrant and so on. So I have the Tailcall one here and I just save ESCO desktop and I pick the

16:52 folder and it's actually here. This is this is the remote one so it's it says your

16:57 code or and I can just edit good here. If I open a terminal, I can use git here, find it all the

17:07 many tables in my SSH keys and the search stuff. I can run an HTTP server and it

17:15 will automatically forward ports. It is just awesome. Anyway, so let's move on once I had this setup. I was browsing for more issues on that

17:30 go right and because I had such a success with solving an older issue, I started to look

17:39 for older issues that haven't been touched in a how. So the issue that I actually started doing after that was

17:49 Tailcall and they showcase URL. Let me just close these tabs. This was not a good idea.

18:00 So yeah, Tailcall is a GraphQL server or gateway.

18:09 What I can do is you can write a configuration in the you can define the GraphQL schema

18:27 that your server will have.

18:29 And you can tell the actual server

18:31 where to pull this data from.

18:33 So you can pull it from HTTP, for example.

18:36 So you can tell, okay, this is the base URL

18:39 that we're putting from and pull the posts

18:41 from path posts.

18:43 So if you create for posts, all these posts will be retrieved

18:47 from this stash posts. Super simple and also super useful especially what I found it pretty cool for

18:57 is you can kind of set it up to transform a private API to a public API, like call your internal stuff,

19:06 but in the right way, make sure that it's actually valid

19:10 in this GraphQL layer, which is pretty cool.

19:14 So you can use it for one just stuff,

19:15 even if you just have an HTTP API

19:18 and you need GraphQL thing for some reason,

19:20 you can just slap this into it. I actually worked on the AWS integration as well

19:26 so you can just deploy it as a lambda, soon that's hopefully going out soon. But you can also just

19:33 host it on any like an easy to server or any server you can just run and that is all.

19:40 and that is all. It's written in Rust. It's pretty fast. Yeah, that's basically all,

19:48 but they wanted to build a showcase endpoint. So if you have this showcase endpoint,

19:57 you can give it a config URL in the parameters and actually, so if you have this config here it loads it from here and it

20:12 actually forces it and runs creates like an app context based on it and you can query this config

20:20 so even without setting up your own Tailcall instance, you can play around with how Tailcall works.

20:30 Which is very cool. So I immediately drunk on, but even GraphQL, I knew next to nothing about when I jumped in on this.

20:51 I do know a lot of Rust. I code Rust pretty frequently, so that had hints like some work code is written in Calfair Handles.

21:06 I kind of could read that to see how this is supposed to work.

21:10 I sure unit that's read it.

21:12 I had to explore the sort of unit test system that they had at the time, which was cool.

21:18 And then this is just boring stuff. Like, okay, at the feature of the fact, of course, then you're going to have to jump into the config parsing layer

21:26 to see where you can add a showcase parameter

21:30 to the server directive and so on.

21:32 So what I noticed is this is not proper like Algora etiquette,

21:40 but I noticed a lot of people like, sorry. So TiaoKal has it set up that you cannot claim it immediately.

21:47 And you have to be a sign.

21:48 People were like, can I get a sign?

21:50 Can I get a sign?

21:51 Can I get a sign?

21:52 And it's like, it was like, I didn't see anyone

22:00 getting a sign. So I just did it. It's not great. You can do this in other places. I'm not

22:05 recommending that you do this. But yeah, that's what I did. It's not, it's not the best thing to do.

22:15 So I added, so I opened a PR for this. And then let's see what I changed.

22:25 So I had to do this actually took an amount of going back and forth.

22:36 So what I did is I joined the discord,

22:41 and then I could talk more directly with the maintainers and that was super useful

22:50 but as you can see there was like a good amount of iteration that had to happen on here even

22:56 like the initial structure that I did was kind of in on the clean because of the way this is set up

23:00 on the screen because of the way this is set up. So Tailcall basically has these Io

23:06 abstractions like HTTP Io file Io and Vio because it can run on so many platforms

23:12 and those platforms may not necessarily have like a compatible HTTP

23:18 implementations with each other. So what I did is I took an input for HTTP Io and I think basically HTTP Io because

23:31 that's really what showcase needed and then for file Io and I created dummy ones because

23:39 they were still required and like down screen functions that I was calling but I didn't

23:44 really want to

23:45 implement them because they could like both security risks. So if you had

23:49 like just a public instance running showcase and you had file IO available to

23:55 the showcase function, it could read local files based on the config parameter,

23:59 which is not not ideal. So I created these dummy file IO stuff.

24:08 Yeah, dummy file IO just because I needed to pass something to these downstream functions.

24:16 And that then turned out to be the preferred solution.

24:19 So there was a lot of back and forth on this.

24:21 Also just the way this project worked. there was a load off like downstream.

24:28 But a lot of like simultaneous API changes going on internally. So as I said, like, okay,

24:34 fix. Okay, I think I can find the commits here that's just keep up with changes. But yeah,

24:38 that's basically what I use. Keep up with API changes. Yeah, so if someone else changes something, you do have to go back in and fix what has been changed.

24:52 Yeah, but this was,

24:56 so this was a long process because it was a completely thing to do.

25:02 And also I just this was like a project where I really had to

25:07 like actively talk with the maintainers to get things shipped, which is not an issue, of course,

25:21 but it is something that you have to do on Algora, that you wouldn't necessarily have to do

25:28 somewhere else and like if you were like working on your own project of course, you don't have anyone to chase after

25:37 So that was unexpected actually to me just the amount of like social battery that I needed to like keep keep these things going

25:40 of like social battery that I needed to like keep these things going.

25:46 So I opened this. It was a straightforward thing.

25:54 But it seemed like a straightforward thing. Turns out it wasn't

25:58 this actually got a spin-off PR that changed some underlying API stuff.

26:00 spin off PR that changed some underlying API stuff and then we could actually do this in a clean way.

26:13 So this took quite a bit of time to get resolved. In the meanwhile, I was also doing some other technical stuff, but I was also looking at other bounties

26:29 and Mendable kind of struck me as one that I could do.

26:36 So Mendable AI is there an AI company essentially.

26:44 Let me show you there letting page real quick.

26:50 Is this gonna know?

26:52 My computer does not particularly like me right now. and Hopefully that fixes it.

27:37 Anyway, I'm not going to deal with that right now, but Mendable is they are basically

27:51 in a mixed source. So you can like sort of consume your docs and your knowledge base and you can you can basically like, Jesus.

27:56 So you can basically consume your docs and your knowledge base on your knowledge base

28:01 and you can create an AI chatbot based off of that, which is a pretty cool idea.

28:09 I don't know why I just opened it here. Give me a second here. I am very sorry. This is not going well.

28:19 But yeah, so a lot of people use this and they are a started to work

28:25 directly tickers with what you let's you that's you that you use and

28:30 that's not happening that would so basically they wanted to have a

28:35 different in this repo that you ingest data from a public GitHub repository

28:44 and the ingest data from a public GitHub repository.

28:45 And the value is... . the two

29:26 two was making from Cal.com or Telecom.

29:49 But I did actually go for it because I just seemed something that would be quick and easy.

29:52 It turned out to be quick, they really turned out to be easy.

29:55 They also had, so one thing that really

29:57 signal to me that this was going to be quick is they

30:02 said, other attempts.

30:04 So do not start working on this before getting assigned,

30:06 otherwise we can't avoid the bounty, other attempts will be allowed if the user assigned does not open and PR within 48 hours.

30:13 So we have two days to do this, and they also said if merged and is of high quality within 24 hours of the assignment,

30:22 a 10 out tip will be what added. So what this

30:25 signal to me is that they are on top of their shit and this will be if I can put the

30:32 work in to get this done quick then this will be quick and there won't be a lot of

30:38 back and forth and won't be a lot of so like refactoring that will have to be done.

30:40 So like refactoring that will have to be done.

30:45 So I jumped on this after the time expired

30:50 and I opened a PR the same day I think or like maybe the day after.

30:57 So yeah, I actually encountered a good amount of issues with this one. GitHub was, so GitHub has a really tough rate limit based on on your authentication level. you are not you don't have an identity of okay I'm this user making these calls

31:25 if you are unauthorized then then you can only make I think 50 requests in five minutes

31:36 yeah 50 requests per five minutes which is not enough to scrape a repo, like, however big or small it is, it's just simply not.

31:47 So, I actually had to add a GitHub authentication method.

32:01 So, the original scope was a public GitHub integration which you need

32:05 sign in but that just wasn't feasible unfortunately. But what I could actually

32:15 do is I could add this authentication stuff and it would work with private

32:20 repos also which is super cool because they did eventually want to build a private

32:25 repo integration as well. So, the so the project structure of this one was actually really

32:35 easy to grasp and super cool, just because it's really just like it's meant to be a modular thing.

32:40 It's really just like it's meant to be a modular thing

32:43 So I could just look at any one of them see where they were the

32:49 Where they were declared and I could just repeat that

32:52 Which was super easy and super useful. I also

32:58 Where was this?

33:00 So I also had to add, this is not like here.

33:00 So I also had to add

33:08 I did OctoKit because they said use OctoKit.

33:12 You can use Axios for this if you know what I increased the project footprint, but it was just, yeah, sure OctoKit.

33:20 So what they wanted is they wanted like a document only mode so you can either

33:26 ingest everything including the code or only documents which is like more

33:30 down, more down X, text and RST. So that's the here we have a little

33:41 helper function. I can actually just run through this code really quickly.

33:45 It's just not a lot.

33:48 So they have like a data provider.

33:51 Crossed that is implemented by every provider, which is super nice.

33:56 And they also support something called Nango, which is super cool.

34:00 And I'm going to show it to you. Mango sort of centralizes all your OAS secrets

34:05 and all your OAS providers.

34:08 So you can just integrate with everything

34:11 and just like add it to your project really easy.

34:13 They basically have an API wrapper built in as well,

34:16 but I'm not using that because, after again,

34:19 but you can just set up authorization really quickly without like cajigering config variables in your

34:27 environment file and stuff like that. So this is very very cool. They actually use this. So it was Yeah, so I went in and in regular authorization,

34:54 Nango authorization, which is really easy.

34:59 And then the get document is like the heart of this.

35:03 It determines the default branch.

35:07 If you didn't define the branch in a config.

35:11 And it gets the branch, it gets the get tree.

35:15 This is like a really obscure part of the get help API.

35:18 So it was kind of hard to be able to Google for this.

35:23 Let me move my camera real quick,

35:25 just because it's an unfortunate place.

35:30 So you have the Getery here,

35:34 and then you get the files from it.

35:36 You if it's only, if the configuration says

35:41 only import files from here, then I check the path.

35:46 And then if Doc only I filter by extensions and then I just get the blobs this is what really

35:54 killed the limit just that you have to get the get each It's just to API call consuming.

36:09 And yeah, I don't know. I had to get some stuff. I just added that stuff for that.

36:27 And then we have document type.

36:32 I wasn't sure because it wasn't defined anywhere like what this is.

36:37 Turns out it's just like fed to the AI so it doesn't really matter.

36:41 Like what it is. So you can just write everything that it does pretty cool. cool And the rest is just boiler plate and just adding tests which was also easy because Bango is awesome

36:55 Yeah, so adding a GitHub provider to this was really fast and just the whole like

37:00 fast and just the whole like run down of okay I am adding this and then okay it's

37:07 merged and I get rewarded was what like a day I think Nick reviewed it the same day And then yeah.

37:30 I got, I also got a tip for 20 bucks, which was cool.

37:34 And it was just really fast and it wasn't.

37:37 So this is what I meant when I said that these two are very different types of projects.

37:46 So, Tailcall, you have to do a lot of work,

37:52 and it's not really fast, but the rewards are bigger.

37:55 A Mendable is just quick things that you can do,

38:00 and the run through is really quick, but the rewards are smaller.

38:05 You will find projects of both kinds on Algora,

38:11 but this is my personal experience with these.

38:16 So I also added a notion data provider,

38:20 a driver data provider, a conference data provider,

38:23 a sales force data provider, a conference data provider, a sales full sales force data connector.

38:26 And what was really interesting is that because I

38:32 jumped on the GitHub one and got it done, then I jumped on the

38:40 let's close everything else.

38:43 Then I got on the notion one and I was already tagged by Nick to

38:48 uh, work on this.

38:51 And then I was uh, on the gyro one.

38:58 I think I was tagged by.

39:01 Oh no, I also jumped on this by myself or no yeah I was also I'll ask my neck to get on this and then on the

39:15 confluence one which was particularly horrible oh no sorry I think it was the Salesforce one that was bad, but

39:27 I don't know where but someone tagged me here to get on it.

39:38 Think it was Rishi.

39:40 I don't know why I can't see it now.

39:45 Anyway, so just by building something really fast and really quality,

39:52 really high quality, you can get a reputation as someone who can do these sorts of things.

40:00 I also saw this with, I think, digital Phoenix. I'm not sure I'm remembering that name correctly,

40:07 but with Refect, they did a lot of stuff with Refect and I scrolled back and that's how they did it.

40:16 If I remember correctly, is that they were there at the beginning, they sold an issue with Eval and they just became to go to person to do this kind of stuff.

40:29 Which is awesome and you are not too eight to actually do something like this. There are new projects

40:34 joining Egoara and yeah it's totally something like you can just become a key player for a certain type of task in a project which is very cool.

40:47 So yeah, I also did some fun things in here. Like in the notion data connector, I actually had to write a markdown converter to convert like notion locks the markdown

41:06 Which is pretty like nasty, but it does like actually work and run well, so it was cool

41:15 And then I did because I wrote this I could also borrow this code to

41:20 work on gyro and confluence and so on and so forth. So that was basically what I did

41:20 work on gyra and confluence and so on and so forth

41:29 for Mendable and then the more interesting stuff that I did is on Tailcall actually with

41:39 the execution-spect, natural testing framework which was really cool. I think this is one of my coolest projects

41:52 So what what they wanted was

41:57 Basically they had like two sort of test suites that it had a graphQL spec

42:03 Which was kind of like four test

42:07 types in itself of like you could provide a server file and make sure that it errors

42:14 and that the error messages added you could provide a server file and make sure that it

42:18 builds and that the client schema is correct. You could also provide a server file and run a GraphQL query on it,

42:31 like just like raw, not even like M2M,

42:35 but just like on the GraphQL part.

42:37 So you could do a lot of stuff.

42:39 You can also test merging multiple GraphQL server

42:43 as the else to test that behavior.

42:47 And they also had a different thing called HTTP spec and that was the end-to-end thing

42:53 where you could define a config, a GraphQL config, and then you had the sort of mock

42:59 endpoints and assertions, and then you could, so the config will target the mock

43:05 endpoint to get the data and then the assertion will query the server to make

43:11 sure that the config actually works. But this, like, there were at least two types

43:17 of files in like different places which was pretty messy.

43:28 And so they wanted someone to create a new testing

43:34 and execution spec, testing like spec.

43:40 That combined all these would actually merge HTTP

43:44 spec and graph U aspect and

43:46 They basically wanted it to be written in markdown

43:51 So you can write config here's your config assert is your assert and then the assert will target the config

43:59 This is pretty cool and I jumped on this

44:04 Ace app This is pretty cool and I jumped on this ASAP.

44:08 Let's see, because this is actually pretty overwhelming.

44:13 So they used the Insta, so yeah, I was asked to use the Insta Stapshot framework,

44:20 which is something really cool. I'm not sure I can pull it up right now. Hopefully that's the right page.

44:30 Oh, holy. Oh, why is it blue? Alright, this is blue. Oh, God. Oh, God. Okay, my brother is dying.

44:40 my browser is dying. Yeah, so here we have Instance Nebula. So it's a sort of like a snapshot

44:46 testing framework where you don't actually write assertions. You create snapshots of your output

44:54 that you would normally assert and then if the snapshot is different from the last snapshot that was

44:59 created it fails and then if it was expected to fail because you're output changed, then you can just quickly accept the new snapshot. Or

45:08 if it fails because the output is wrong and your code is wrong, then you

45:13 can fix your code and wait for it to match the snapshot actually.

45:18 Which is pretty cool. You don't really have to

45:24 rewrite a lot of tests when you change something that actually

45:27 should be changed.

45:30 You can just auto accept this stepshot, which is great.

45:36 Getting this to work was a bit difficult just because of the sort of messy stuff in rust testing and just like rust serialization in general.

45:49 So I had to I think at some point I had to like enable a weird feature flag on

45:57 thirded JSON to get JSON to serialize, to retain the order of JSON keys so that the snapshot would

46:07 just like dance around and fail. Which was interesting but it did work so.

46:20 Oh, really? I can pull this up. 497 file exchange because one of the requirements was also to write a

46:38 test converter and actually convert, be able to automatically convert every single pre-existing test to use the

46:48 execution spec format, which was also something that was pretty cool to do. I may actually have to

46:55 open this in VS code because GitHub is just dying right now. So now that we are in VS code,

47:00 now. So, now that we are in VS gone, the turning console, do I want that? Yeah sure actually that's fine.

47:12 Uuuh, Yish! It is not happy, okay, let's see what I can close.

47:19 I just close everything else but this is like okay that should be better.

47:28 Adios of RAM is not enough for this machine. Anyway.

47:40 So we have execution spec right here.

47:45 This is what's used to parse the markdown spec and actually perform it. I based this off of the pre-existing like HTTP spec,

48:05 engraved UL spec, which doesn't actually exist anymore.

48:10 I think, yeah, director is empty.

48:13 But yeah, I was basically able to use that to create my own spec.

48:19 And then we have something like test.

48:24 Oh yeah like test.

48:27 Oh yeah, test, no way, so you're out. So this is what I was talking about.

48:29 You can test, you can make sure that it errors out.

48:32 So you say, okay, as the L error,

48:35 so this is expected to error out

48:37 and then you define the server that's just wrong.

48:52 And so if we take a look at test no base URL snap, you can see that this was the error that was outputted by this. And that's what's verified again on every test run.

48:59 So there's also a bunch of this, Like sometimes you need to explicitly define that you wanted to perform like a merge check,

49:11 which meant that for every single time you edit the merge stuff,

49:15 you need it to, you usually need to create a normal test of like an HTTP spec test that actually tests what you are doing and

49:25 then you also needed to create a merge test

49:30 Because you changed the merge stuff. I don't know you had a config parameter or something and then you should have created a

49:38 a test for that. Sometimes that wasn't done and sometimes

49:40 that wasn't done and sometimes stuff failed. So now I added that everything is automatically

49:42 stuff failed so

49:50 merged tested so that you don't need to declare that explicitly it's automatically done done everything which increases the coverage. A considerable amount.

50:07 I also wrote a dog for this, which basically describes like how things are supposed to be written,

50:15 but I think we can learn better from example here.

50:18 So let's see, that's JS Hello World.

50:21 I don't know if the vitro-fi system is in here yet.

50:24 Yes it is. Okay, let's world. I don't know if the virtual file system is in here yet. Yes, it is.

50:26 Okay, let's go.

50:27 I'll talk about that later.

50:28 So you have a server block right here, which describes your GraphQL server.

50:34 I don't know what this is doing.

50:38 And then you have a search and block that actually runs the request. And then, as you can see, there is no like expected response

50:48 here.

50:49 So it's not technically a search and but it is because if you do

50:53 testjs, hello, oh, MD assert zero that snap, then you can see

50:59 that this is the response.

51:01 This is the expected response.

51:03 It was automatically generated by a known good build.

51:06 So this is the expected response stepshot. And then if you break something, it detects that

51:13 the actual data does not match the snapshot and then it fails. So you have the assertion here. This just describes, okay, call this and with this query.

51:28 And then this is the server config.

51:31 And you can actually do stuff like link JavaScript to it.

51:34 So you can like script some stuff.

51:37 So for that, we I also added a like a mock file system.

51:44 So you can just disdefined files.

51:47 So you can say, okay, file, Tesla JS, JS, and then it's just, your file is here.

51:57 And if you say, okay, open Tesla JS, then the mock file I that I created reads this, which is cool.

52:10 The really just the point was to be able to centralize everything into one file that for one desk case or desk spec.

52:25 You can also do stuff like one thing that's also done is if you have a server block

52:36 anywhere, it also automatically generates a client.

52:41 So all the client specs or all those GraphQL specs that check the client

52:47 generation are now also obsolete and are automatically done for everything and even more cases

52:53 that were done before. So you can say, Executions pack test JS, client. And here's the client that was generated.

53:06 So this is pretty straightforward.

53:10 The magic actually happened in test cone,

53:14 which automatically converted everything to

53:20 to the new format.

53:24 So if I open test column here, so what it does is, it's pretty big

53:34 just because it had to handle like a lot of stuff. So it opens the old tests, reads everything from them

53:42 and sort of tries to parse them. So for example, the HTTP specs name, YAML.

53:47 So it parses them.

53:48 It basically turns and it, yeah.

53:51 So it emits markdown.

53:54 That can be put straight into the new execution spec file.

53:58 And there were some stuff in the original format,

54:01 like fail annotations.

54:06 Saying that, okay, this is expected to fail,

54:08 that we couldn't actually support in the new version

54:16 because you cannot really,

54:19 instead doesn't like that you expect a snapshot to fail

54:23 because that's kind of dumb. If you

54:27 expect it to fail then just save the phoenix snapshot. Is the philosophy there. So what we do

54:33 is exactly that. So if we detect that there's a fail annotation we actually run the test suite

54:42 and save the phoenix, which is pretty cool.

54:48 And this is repeated for everything else.

54:52 There's also a lot of edge cases that need to be handled, which took most of the time

54:56 when building this test count.

54:59 But yeah, and it automatically runs pretty here prettier because you want your execution spec to be formatted

55:09 See yeah, this the task on was the most complicated thing in this

55:16 In execution spec it was pretty easy because I used a like a markdown parser that created the asked tree that I could just walk and get everything

55:28 and turn it into a rust-like struct. So this was really just a super interesting thing to tackle,

55:37 which really helped me because I couldn't really use this basically fondant project to keep my motivation up while also doing stuff that was a little bit harder and convenient or demotivating.

55:52 So you should always just have a bounty going in the background that is actually really interesting to you. Even if it's not like really high reward maybe or it especially if you're doing like a lot of other bounties that feel like Scott work,

56:10 it can really help a lot to be doing a bounty at the same time that you can just go back to

56:16 and work away at it if you just need a break or need to do something else.

56:20 or need to do something else.

56:25 Yeah.

56:27 So that's basically everything.

56:33 There's also one more thing,

56:35 we'll tell you on contribution that we can talk about.

56:38 That is a bit interesting.

56:41 We have AWS Lambda.

56:44 And I just, I was really banging my

56:48 head against the wall trying to figure out like what's in elegant way to do this

56:52 and I actually ended up using Terraform to create a deployment which is a

57:02 super useful tool not only if you want to like set up your project

57:08 for yourself, but also if you want to allow someone else to set up your project as a part

57:18 of their own deployment. So if we take a look here, I don't think that one is merged yet, but we can go to

57:26 Mogery

57:30 Tailcall on AWS

57:34 There we go.

57:38 So what this does is it's basically just a Terraform file.

57:43 But if you wanted to put, if you wanted to deploy Tailcall on AWS,

57:46 this is the only repo that you need to clone. And the only thing that you wanted to deploy telcalon AWS, this is the only repo that you need to clone and the only thing that you need to have installed is Terraform. Because what it actually

57:53 does is it pulls the latest Lambda build from the telcal GitHub as page. So you don't need to really build anything on your own.

58:07 If you just get the Tailcall binary from the releases,

58:16 which is pretty cool, and it also gives you auto updating.

58:19 So if you deploy your project,

58:22 if you redeploy your project or if you update,

58:24 I think that's the Terraform term. If you update your project, if you redeploy your project or if you update, I think that's the Terraform

58:25 term. If you update the project, then you can just...

58:30 So what this does is it always gets the latest telecoveredies.

58:36 So if Terraform just detects that you have a newer release of the Tailcall call than the one that was the last deployed. It just downloads it.

58:45 Again, reconstruct the zip and put it on AWS.

58:49 So, Terraform is really just a super useful tool to ship stuff that has great DX.

59:00 Because infrastructure as code is the best DX that you can give when you are trying

59:10 to help people deploy stuff.

59:13 So this will be the end product of the whole AWS thing.

59:18 It's not super ready yet mainly because I was busy with other things. And I wasn't really available to drive this.

59:26 But as you can see, there are already

59:29 like op poles, wait, I'm good to poles.

59:33 I'm meant to go through releases.

59:35 So if you check the tail cover, the least is,

59:37 you can already see like,

59:43 Tailcall, AVS, AWS, and check the code. We have to check the code.

59:48 We have to check the code.

59:50 We have to check the code.

59:52 We have to check the code.

59:54 We have to check the code.

59:56 We have to check the code.

59:58 We have to check the code.

01:00:00 We have to check the code.

01:00:02 We have to check the code. We have to check the Okay, how are we going to configure Tailcall because Tailcall needs a configuration

01:00:08 that you need to be able to deploy

01:00:10 along with your image.

01:00:14 So what I actually ended up doing is,

01:00:16 if you go to AWS Lambda,

01:00:21 you can see that,

01:00:35 it's actually read from just a local file on the Lambda machine. What I actually ended up finding most convenient is bundling this config file with the image itself.

01:00:53 So that allows you to not really need to go to like some AWS panel and upload your config into there.

01:01:05 You can just update your config.graphical here.

01:01:08 And when you update it,

01:01:10 Tailcall what the tag that you've changed the file.

01:01:12 It will rebuild the bootstrap zip

01:01:17 and it will upload it to Nanda and it will be up there.

01:01:26 You can try this better DX and TF.

01:01:28 Oh, Pulumi.

01:01:29 Yeah, absolutely.

01:01:30 Pulumi is also awesome.

01:01:35 I ended up going with TF because

01:01:41 it was just the thing that I had most experience with.

01:01:45 It actually came from the code or stuff.

01:01:48 But it's, I think it's definitely something that,

01:01:55 multiple of these infrastructure-scode solutions can do.

01:02:00 And I think the best thing would be to implement all of them.

01:02:04 So if you are deploying Tailcall to AWS, you can just choose.

01:02:09 If you are already using an infrastructure as code project or like solution, then you can

01:02:14 just choose the one that's written in the same thing.

01:02:17 And you can sort of like intertwine it with what you are already deploying.

01:02:22 So yeah, absolutely. Pulumi is also awesome. And I think

01:02:29 that's definitely something that needs to be added here once we get this first initial

01:02:33 version merged. I'm actually writing that down.

01:02:40 Thank you for reminding me about that.

01:02:49 Yeah, that is it.

01:02:53 I think I don't really have anything more planned today.

01:02:59 I unfortunately have to work on non-Algora stuff today. Otherwise, I would be just live working on some interesting stuff.

01:03:10 But that is not the way something I can do.

01:03:12 Unfortunately, but that will be something that I will definitely do in the future

01:03:17 in this Mogery's code sessions format.

01:03:22 So the Calford app. But I think that that is it on

01:03:27 us. Anybody has any questions in the chat. Let me see if there's anything else

01:03:37 that I missed.

01:03:40 Yes, so, support 1000 spec. This was what added the virtual file system to the execution

01:03:55 spec. What was really cool about this is, while I was doing it, I just felt that I've, I've like, messed with this code base enough

01:04:07 to be able to do something like this.

01:04:08 And that's really something that you can do

01:04:13 by jumping between all these boundaries.

01:04:16 Is you can just really like develop that skill

01:04:19 of being able to adapt to other people's code

01:04:21 and being able to look at it and actually understand. It's not

01:04:25 something that will be easy for the first time. I struggle with this a lot. But I've also been doing

01:04:31 like, I've been looking at code for like 10 years now. So it's obviously something that you get

01:04:38 better with over time. But just because of doing other boundaries, I just knew enough about other

01:04:51 boundaries in Tailcall. I mean, I just know enough about the code base to be able to just go in

01:04:56 confidently and build this because I already knew where everything was. And that is what's great about doing boundities for the

01:05:08 Australian projects and that is also great but if you hope between

01:05:17 projects you will get better at this even more so really you don't really have to like like pick a strategy of like,

01:05:28 okay, I'm going to work on this project only or okay, I'm going, I'm never going to

01:05:32 work on the same project again and I always want to do something different. Really,

01:05:36 anything that you do will actually develop your skill set as a developer.

01:05:40 up your skill set as a developer.

01:05:48 Thank you, McPeeze, and I'm very glad that you enjoyed this session here.

01:05:53 And yeah, I think that is it.

01:05:57 So I will...

Library

51:15

Doing some open-source bounties & messing with Nix

Gergő Móricz

2 months ago

01:04:31

Doing some open-source bounties & messing with Nix

Gergő Móricz

2 months ago

01:06:00

My contributions to Cal.com, Tailcall, Mendable, and more...

Gergő Móricz

2 months ago