Skip to content

From Skeptic to Advocate, Scaling Effect at Vercel

Aug 4, 2025

#4: From Skeptic to Advocate, Scaling Effect at Vercel

In this episode of Cause & Effect, Johannes Schickling is joined by Dillon Mulroy, Domains Lead at Vercel, who shares his personal journey with Effect and how Vercel gradually adopted it across their Domains platform. Dillon explains why Effect feels like having superpowers for error handling, observability, testing, and more.

In this episode of Cause & Effect, Johannes Schickling is joined by Dillon Mulroy, Domains Lead at Vercel, who shares his personal journey with Effect and how Vercel gradually adopted it across their Domains platform. Dillon explains why Effect feels like having superpowers for error handling, observability, testing, and more.

Song: Dosi & Aisake - Cruising [NCS Release]
Music provided by NoCopyrightSounds
Free Download/Stream: http://ncs.io/Cruising
Watch: http://ncs.lnk.to/CruisingAT/youtube

  • (00:00) - Intro
  • (03:00) - How Vercel Adopted Effect
  • (10:57) - Dillon’s background
  • (16:27) - Effect DX
  • (22:13) - Lessons from other stacks
  • (25:18) - From Skeptic to Advocate
  • (31:13) - Effect’s Incremental Adoption
  • (42:31) - Effect ≠ RxJS, Effect vs Ramda
  • (48:24) - Effect’s superpowers at Vercel
  • (52:31) - Wrap-Up & What’s Next
Discuss this episode on Discord

Transcript

00:00One of the points I've made in my

00:01conference talks this year is that to

00:04scale TypeScript on

00:05the server effectively,

00:07it requires discipline and discipline

00:09doesn't scale at the

00:10organization level, unfortunately.

00:12the very

00:12primitives and foundations of the

00:14language make it easy to have

00:17happy path blindness,

00:18where it's very easy to neglect all the

00:20things that can go wrong in our software

00:22and just write the happy path and not

00:25consider the error states we can get in,

00:26which over time just leads to slop.

00:29And on top of that, we don't have a

00:31framework. Well, we do now with Effect,

00:33but traditionally, Node hasn't had a

00:35framework like Spring Boot or Ruby on

00:37Rails or Laravel, right?

00:39So we are consistently and constantly

00:41downloading dependencies and trying to

00:43mix and match them where they were never

00:45designed together or cohesively.

00:48And you end up reinventing the wheel for

00:49all of the things that

00:50Effect provides out of the box.

00:55Welcome to Cause & Effect,

00:57a podcast about the TypeScript library

00:58and ecosystem called Effect,

01:01helping engineers to build

01:02production-ready software.

01:04I'm your host, Johannes Schickling,

01:05and I've been building with

01:06Effect for over four years.

01:08With this podcast, I want

01:09to help others understand

01:10the powers and benefits of using Effect.

01:13In this episode, I'm

01:14talking to Dillon Mulroy,

01:16a software engineer at Vercel working on

01:18their Domains product.

01:20In this conversation,

01:21Dillon shares his path to Effect

01:23after years of using

01:24other programming languages

01:25such as Golang and OCaml.

01:27We dive deep on how Vercel

01:29incrementally adopted Effect

01:30and which new

01:31superpowers it had unlocked.

01:33Let's get into it.

01:34Hey Dillon, so great to have you on the

01:36show. How are you doing?

01:37I'm doing well. It's an

01:39honor to finally be here.

01:41You're probably a person who really

01:43doesn't need an

01:44introduction in the Effect community,

01:47but for those who are very

01:48new to the Effect community,

01:50would you mind introducing yourself and

01:52sharing what you do?

01:53Yes. So my name is Dillon Mulroy.

01:56I am a Software Engineer at Vercel,

02:00and I am the Technical Lead in our

02:03Domains Product areas.

02:05So Domains, Registrar, Buying domains,

02:07managing DNS, TLS and certificates,

02:10aliasing domains to deployments.

02:13We've been going all in this year on

02:15Effect on all NetU domains work,

02:18and we're starting to see the fruits of

02:20that labor and are very exciting times.

02:22That is awesome. I want to dive a lot

02:24deeper on all of those aspects.

02:27I want to also hear

02:28about what led you to Effect,

02:30but maybe we remain for a few minutes on

02:33Vercel on a high level.

02:35Like how should I think about Effect

02:38being adopted at a company like Vercel,

02:41which is very cutting edge. It builds

02:43developer tools itself,

02:45and I think it really needs to moderate

02:47where it can take a lot

02:48of risk on new technologies

02:50and where it needs to be

02:51a bit more conservative.

02:53So maybe you can share on a high level

02:55already how Vercel

02:57started to adopt Effect.

02:59Yeah. So I actually admit I was not

03:01the first person to write

03:03lines of Effect at Vercel

03:05It was probably either Toby or Schnez,

03:08have a couple small Lambdas that run,

03:10that they probably

03:11wrote a year or so ago now.

03:13But I was certainly the first person to

03:16build larger services and

03:18kind of take it on holistically.

03:21I think as is with the story with Effect,

03:24there is apprehension when you first see

03:26it and read it. I had

03:28the same apprehensions.

03:29But as I talked about, both

03:32Effect Days and React Miami,

03:35Effect solves the pain points that makes

03:37writing TypeScript at scale difficult.

03:41And we, at least my team, is truly

03:44starting to see the

03:45benefits of that with Effect.

03:48I'm sure we'll dive into more specifics

03:50on that, but it has truly made us faster.

03:53It has made us ship more reliable

03:55software across the

03:56board with better telemetry.

03:58We have distributed tracing that just

04:01works without headaches.

04:03And I would argue we have some of the

04:05best DX across any team at Vercel for

04:08shipping internal services.

04:10That is awesome. Well,

04:11TypeScript wasn't your first love.

04:13I'm not sure whether it is a love at all.

04:16From what other people might know you

04:18from is from the OCaml community, also in

04:21the NeoVim community.

04:23So I'm curious, maybe we can take a few

04:25steps back and take a look at your

04:28personal background.

04:29You worked previously at Formidable, and

04:31I think you worked in

04:32consulting before that.

04:34Maybe you can just share a bit more about

04:35your background and the

04:37trajectory that's had you on.

04:39Yeah, I've kind of had a

04:41pretty unique background.

04:43I've had the opportunity and privilege to

04:45work in a lot of different

04:48companies through consulting.

04:49And I've also got to work in a lot of

04:51different tech stacks.

04:53And maybe most importantly, I've got to

04:56work in and experience many different

04:59engineering cultures and engineering

05:01organizations within companies.

05:03I'm in my 11th or 12th, 11th year. I

05:07started in 2014 full time.

05:09As an engineer, my first job was at State

05:11Farm. I was doing full stack dev, Java on

05:14the server and

05:15JavaScript on the front end.

05:17I was like on one of the teams that made

05:18their first step into span apps.

05:21And I actually got to start writing React

05:24at that job very soon

05:26after it was announced.

05:27from Jordan and Tom. So I've been

05:30writing React for over a decade now.

05:32I've seen it from the days of mixins and

05:34class components up through now to we're

05:36at RSEs and server

05:37components and server functions.

05:39So most of my career, like my bread and

05:41butter truly is

05:42TypeScript and JavaScript.

05:44But I worked in Go for two years. I had a

05:50contract doing some Elixir.

05:52I notably had a two year gig at a startup

05:54doing OCaml full stack both

05:56in the front end and back end.

05:58And then at Formidable, that Formidable

06:00was certainly the job that changed the

06:01trajectory of my career.

06:03And Formidable back in 2016 to 2021 era

06:08had kind of a similar

06:09reputation, I think, as Vercel.

06:12We had a lot of very notable developers

06:14in the open source JavaScript community.

06:17So I got to cut my teeth alongside people

06:19that were on the React Native Core team

06:21that were involved

06:22with GraphQL super early.

06:25And then again, I think the most valuable

06:26thing that came from working at

06:27Formidable was the fact

06:29that it was a consultancy.

06:30And I was getting dropped into all these

06:31different engineering organizations and

06:33not only having to

06:34figure out technical problems,

06:36but also like people and process

06:38problems, which end up being the harder

06:40problems in tech and

06:42ironic, maybe not ironically,

06:43but I think Effect actually

06:44helps address some of that.

06:48Actually, that's a very interesting

06:49topic. How would you say

06:51that Effect helps with that?

06:53I think it's very hard to manage

06:54TypeScript and specifically TypeScript on

06:57the server at scale, probably past.

07:01If you're in an engineering organization,

07:02I'm just going to throw out

07:03an arbitrary number, like 100.

07:05If you have over 100 engineers and you're

07:07starting to get tens of services, I think

07:09that's where Node

07:10really starts to break down.

07:13One of the points I've made in my

07:15conference talks this year is that to

07:18scale TypeScript on

07:19the server effectively,

07:21it requires discipline and discipline

07:24doesn't scale at the

07:25organization level, unfortunately.

07:27And what I mean by that is just the very

07:31primitives and foundations of the

07:33language make it easy to have whatever to

07:38refer to as happy path blindness,

07:39where it's very easy to neglect all the

07:42things that can go wrong in our software

07:44and just write the happy path and not

07:47consider the error states we can get in,

07:48which over time just leads to slop.

07:52And on top of that, we don't have a

07:54framework. Well, we do now with Effect,

07:57but traditionally, Node hasn't had a

07:58framework like Spring Boot or Ruby on

08:00Rails or Laravel, right?

08:02So we are consistently and constantly

08:04downloading dependencies and trying to

08:07mix and match them where they were never

08:09designed together or cohesively.

08:11And you end up reinventing the wheel for

08:13all of the things that

08:14Effect provides out of the box.

08:16So would you say that Effect forces

08:19engineering teams to be disciplined or

08:21would you say that it

08:23makes being disciplined easy?

08:25Oh, man, that is great. I would say both.

08:28Honestly, I think the

08:29rigidity of Effect forces discipline.

08:34But at the same time, like it makes all

08:37the hard things of

08:38writing Node on the server easy,

08:40whether that's testing and mocking or a

08:42dependency injection,

08:44telemetry in one line,

08:46having things like semaphores

08:49and just nailing concurrency easy.

08:51It's just all of like all the hard things

08:53you end up reinventing in

08:54every project and every service.

08:56It's just there and it's like bulletproof

08:58and it's composable and it just works.

09:00So I think it almost

09:01tackles it from both angles.

09:03What I think is really interesting about

09:05your career so far, there is a few

09:07parallels that I can relate

09:10to from my own experience,

09:12having used many different

09:14languages over the years.

09:16And I'm still sort of emotionally

09:17confused how I feel about

09:19JavaScript in that regard,

09:21that it's certainly not by far not the

09:24most beautiful language I've ever used.

09:26For that, I think my heart is still in

09:29Haskell land, but Haskell is not

09:32practical for all the

09:34different things that we want to do.

09:36And then I've also like having done quite

09:39a lot of Rust development and Swift

09:40development, also a fair amount of Go.

09:43And all of those languages

09:45kind of feel better to me.

09:48But at the same time, I'm still doing

09:51most of my stuff in TypeScript and

09:54there's a reason for that.

09:55I think one is just the ubiquity of

09:58TypeScript and like where it can run.

10:00And then also just like JavaScript

10:02runtimes. there is

10:03probably very little

10:05where so much economical value has gone

10:07into making it fast compared to

10:10JavaScript runtimes.

10:11And it's like very hard to beat.

10:13And I think there's just so many factors

10:15that are going in that favor.

10:17But at the end of the day, it's still

10:19sort of like a crappy environment.

10:21And so this is why I've always kind of

10:23felt, OK, well, I should

10:25rather use a better language.

10:27And when I then found out about Effect, I

10:29think that's now over five and a half

10:31years ago, this is where I

10:33saw the inklings of hope.

10:35Could I get off the things that I'm like

10:38jealous about other proper program

10:40languages in JavaScript and TypeScript?

10:43And TypeScript also

10:44wasn't as far along back then.

10:46First,

10:46I want to hear like how did you first

10:48hear about Effect and whether the sort of

10:50the same thing spoke to you.

10:53I mean, that mirrors my experience like

10:55perfectly, as I said, my

10:58bread and butter TypeScript.

10:59I love and loathe

11:00TypeScript all at the same time.

11:02Until I found Effect and especially

11:04having spent two years working in OCaml

11:07full time, I was feeling pretty

11:09disenfranchised about

11:10writing TypeScript and Node,

11:13especially after having really felt like

11:15what a type system and errors as values

11:17and all the nice things

11:19that OCaml provides you.

11:21I felt so much more confident shipping

11:23quality software with OCaml

11:25than I did with TypeScript.

11:28And it's really not even just OCaml.

11:30The other language that brought the same

11:32feeling to me, even though I don't have

11:34as much fun writing it, is Go.

11:36Like the two software stacks that I've

11:39felt I've built the most scalable and the

11:41most reliable technology with both on

11:44like the technology scaling side and the

11:48engineering or scaling side

11:49has been OCaml and Go and they both have

11:52similar traits for what I consider

11:54important properties in production software.

11:58Errors as values. They kind of force you

12:02to consider the error path at every turn.

12:05And that's just

12:06distinctly missing from Effect.

12:08So like I had I had lost my job.

12:11I got laid off for my OCaml job and

12:13basically came right to Vercel.

12:15And at the time I was like, oh, man, I'm

12:17going back to like to stop writing OCaml

12:20on the server and I have to

12:22start writing TypeScript again.

12:24Certainly, I was excited to be working

12:25at Vercel, right? There's a million interesting

12:27problems here every day.

12:28But around that same time, I had started

12:31to see Effect and like many people, my

12:34knee jerk reaction

12:34was like, this is gross.

12:36I don't want to touch

12:36this. This reminds me of RxJS.

12:39I've, you know, as a junior dev

12:42I've made very sloppy

12:44code bases with Ramda.

12:45So I was initially very apprehensive.

12:47But like you, I saw the shimmers of hope

12:51in it that just like displayed the

12:54properties that I found

12:55valuable from Go and OCaml.

12:57And then on my Twitch stream, I decided,

13:00you know, let's give this a real shot.

13:02Let's build something with it.

13:03That's more than just a

13:04toy app or a to do list.

13:06And that's when I was

13:08like, OK, I see it. I get it.

13:10This brings the things that I value in

13:14building software to the table and makes

13:16it accessible for TypeScript and Node.

13:18Yeah. TypeScript and Node,

13:19it just the ecosystem draws you in.

13:21It has like this gravity.

13:22Yeah, I don't know if I would love

13:24writing software as much as I do

13:25currently without Effect, because

13:28it makes writing

13:29TypeScript enjoyable again.

13:30Totally. There's a couple of interesting

13:33points that I want to

13:34follow up on, like namely,

13:35RxJS, but also the comparison to the other

13:38program languages, maybe

13:39starting with the latter.

13:41It's interesting that Effects on the one

13:44hand is like an absolute marvel of like

13:47engineering on like it

13:49basically unlocked for me,

13:51kind of like multiply the value of the type

13:53system provides like previously,

13:56the type system only was applicable to

13:58the happy path and even there like only

14:00to a certain degree,

14:02like it could still like

14:03give you a false sense of safety and then

14:06things would blow up.

14:08But like the non happy

14:09path wasn't a model at all.

14:12But if you think about it the other way

14:14around, it is like Effect also doesn't

14:17really do so much on a technical level,

14:20but it's actually rather forces like a

14:23different perspective on the

14:25language we're already using.

14:27And I think very similar to how React has

14:30done it, I think it basically

14:31offers just like a different

14:34constrained perspective on like how you

14:36should think about like

14:37opinions, how you should write code.

14:40And through those constraints, you

14:42actually gain a lot of freedom and a lot

14:46of like emergent properties.

14:49And so when you think about like values,

14:52errors as values, it's not like that this

14:54is like a unique new capability that was

14:57now brought to TypeScript.

14:59Honestly, we could have written

15:00JavaScript like from the get go.

15:03I think it was basically just no there

15:05was no cultural critical mass

15:08that really made that a thing.

15:09It could have been another like popular

15:12library, let's say like underscore JS

15:14would have enforced that more

15:16or let's say another length.

15:18Another library would have enforced that

15:20and it would have kind of picked up as

15:23a cultural movement.

15:24But it didn't like people rather like,

15:26for example, maybe

15:28you still remember T.J.

15:30Holloway Chuck, like

15:30the creator of Express

15:32JS et cetera. And I

15:34learned so much from him.

15:36And he I think was at some point like fed

15:38up with that cultural

15:40perspective that he went into and to Go

15:42land and embrace that very fully.

15:45I think there could have been a different

15:47parallel universe where maybe Effect

15:49wouldn't be as relevant today if we would

15:52have already kind of taken those

15:54inspirations from other languages and

15:56embedded it more in JavaScript, even

15:58without any feature changes in terms of

16:02the syntax of JavaScript, et cetera.

16:04As Effect currently like proves, there is

16:07no different syntax.

16:08It's all there. We just need to use it.

16:11This is where maybe my react analogy

16:13isn't as perfect because

16:14it also introduced JSX.

16:16But I think it's the same

16:17sort of perspective on it.

16:19So I'm curious what are

16:20your thoughts on that?

16:21I mean, I completely agree with you.

16:24And like I think going back to like the

16:26beginning of this, one thing I think

16:28people don't realize and maybe that we

16:31don't talk about enough is that we focus

16:34a lot of the time talking about like

16:35errors as values and how

16:36it's tracked in the type system.

16:38But like Effect is insanely good at type

16:43inference for the happy path to like

16:45you're getting the same level of DX as

16:47you're getting from things like TRPC or,

16:50you know, Drizzle or Prisma, like all

16:53these top of the line, very popular

16:55libraries today that people talk about

16:57how good the type reference

16:59is from the front to the back.

17:00Like that is present in

17:02Effect too, if not more.

17:04Table stakes.

17:05Yeah. And I don't think people talk

17:07about that enough, but it brings that

17:09same level of like amazing DX for type

17:11inference from just like the happy path

17:14and co-generating clients from their

17:17front end and back end to the error path

17:19and dependency injection.

17:21And that kind of ties

17:23back to the culture, like.

17:24Error handling and both dependency

17:26injection and like the JavaScript

17:27TypeScript node ecosystem, it just like

17:30haven't really been a thing.

17:34And people even experienced developers

17:36that have been working in this ecosystem

17:37forever, like this reaction of like, have this reaction like

17:41why don't I just throw the errors?

17:43And then it's like once

17:45you start writing Effect.

17:46And I've seen this every developer that

17:48I've introduced to Effect.

17:49At first, it's like, this

17:51is like a lot of resistance.

17:52And then they're like, wow, I did not

17:54realize how many things could and were

17:59actually going wrong in my software.

18:01And it's like

18:02pulling back the curtain.

18:04It's like, oh once you look

18:06behind that curtain of seeing how error

18:07prone software really is and that like we

18:10have this culture of not handling errors.

18:12If you go back to writing just TypeScript

18:14with try catch, like you're going to be

18:17writing a lot more try catches and a lot

18:19more granularity because you can't unsee

18:23how error prone everything is.

18:26And it's always the question of like,

18:28well, does this function throw?

18:29I have to go check the implementation.

18:31Does it dependency throw?

18:33I have to go check their implementations.

18:35And it's like

18:36once you have that realization, it just

18:38makes you want to

18:38reach for Effect naturally.

18:40And I think that's that

18:42aspect is so interesting.

18:44Like people are different. Right.

18:45So some people are naturally kind of like

18:48truth seeking and some others are rather

18:51like already barely getting

18:53by with what they need to do.

18:55And they don't have energy to like learn

18:57something new or maybe they if it's

18:59really required of them,

19:00maybe they they learn something.

19:01maybe they they learn something.

19:01And I mean, this is well reflected in

19:03sort of the crossing the

19:04chasm adoption curve, etc.

19:07But I, for example,

19:08I get very frustrated if I

19:11realize, OK, there's something is like

19:14something could be better.

19:15But then I what I get mostly frustrated

19:17with is if I can't quite see yet how it

19:20could be done better.

19:21And this is where I basically then start

19:23just exploring in sometimes I like leave

19:26the metaphorical country of JavaScript

19:28land to go to other languages, to other

19:31literal languages and see,

19:34hey, how are things done here?

19:36And this is as much of a technical thing

19:38as a cultural thing.

19:40And this is where like in 2020 I started

19:43again, like looking around from like

19:45Haskell to like Scala,

19:48which I've used in the past.

19:49And this is where I stumbled across Zio

19:52and John De Goes, the author of

19:54Zio, has in a very humble move at last

19:58year's Effect Days conference, has sort

20:01of, I guess, paraphrasing here,

20:05like admitted defeat in that regard that

20:09the biggest impact

20:10Zio had is like to inspire Effect, which

20:12now brings it to to a

20:14much wider audience.

20:15But I think this is where I can't give

20:17people like Mike Analdi, etc., enough

20:20credit that they managed to like

20:23take that inspiration and be like

20:26resilient and determined and crazy enough

20:29to like take those ideas and like bang it

20:31against a TypeScript type

20:32system until it kind of fits.

20:35And in a way where it basically like in

20:392020, I would have thought, OK, like

20:41we've kind of reached the peak, what you

20:44can do with TypeScript.

20:45And that's like, OK,

20:47that's just how we do it.

20:48And we do a bit more like unit testing

20:50over here and we do a little bit more

20:52like micro front ends

20:54and like tRPC, etc.

20:57But only once you've seen how much better

20:59it can be, then you realize, oh, my gosh,

21:02it's like this big, big delta.

21:04And and I think this is exactly that

21:05describes exactly the experience that

21:08like people who start working with you on

21:10on Effect things, they realize like where

21:13they basically thought like, OK, there's

21:14like this little little bit of

21:16improvement that I could

21:17make to like layer after layer.

21:20You realize, oh, my gosh, I can write

21:22code so much better.

21:24And this for me is like one of the best

21:25feelings about programming when it's

21:27basically not like you learned once and

21:29then you OK, you know how to like need to

21:32like have a hammer, a nail

21:34and you need to like bang it in.

21:36OK, that's it. But for for programming,

21:39like this has now for like decades showed

21:42me time and time again that there is more

21:44elegance to kind of be mined.

21:46And Effect has been like like on the same

21:49level of like React to me in terms of

21:52like how much elegance

21:53could be exploited here.

21:55So, yeah, maybe you want to share a bit

21:57more about the typical experience someone

22:00has working with you of

22:02being introduced to Effect.

22:05Yes. Yeah. I want to one

22:06thing I want to go back to and.

22:07I think one thing I used to and I still I

22:11don't talk about as much anymore, but

22:12like I think some of the most one of the

22:13most valuable exercises, somebody who has

22:16exclusively worked in the TypeScript

22:19ecosystem can do is step outside of the

22:22language and learn something else.

22:24Like without a doubt in my mind, working

22:27in OCaml and working in Go and working in

22:31Elixir have made me such a better

22:35TypeScript developer because I've learned

22:39practices and patterns from those

22:42ecosystems where they might

22:43emphasize on something more.

22:45But that can apply equally to TypeScript

22:47and just like learning to look at

22:49problems differently, whether that's

22:51concurrency or error handling or how you

22:53manage dependencies.

22:55It's a cheat code, actually. It really it

22:58really is. So, yeah, for anyone listening

23:00that has only ever worked in TypeScript,

23:02learn something new, step outside of the

23:03ecosystem, I

23:05think, and be really valuable.

23:06But working with me on Domains, I'm

23:09kind of in this kind of privileged

23:11position where I got Ethan and Elliot on

23:13my team who are also two very notable

23:15Effect developers in the community.

23:16But we also have Rhys Sullivan on our

23:19team who has started writing Effect.

23:21And like when I was speaking earlier of

23:23people starting to write and, you know,

23:26peeling back the curtains or having these

23:27aha moments like I was thinking of Rhys.

23:30It just becomes so clear like the

23:33minute even like so up until maybe like a

23:36month ago, Rhys hadn't written a lot of

23:38Effect code just because he is working on

23:40different kind of more legacy priorities

23:42than a lot of our Effect code is.

23:45But he's been reviewing the PRs that the

23:46whole team has been writing in Effect and

23:48like he's become very

23:49capable very quickly.

23:51I think there is a there's a perception

23:52problem of Effect on like how hard it is

23:56and how different it actually looks,

23:57which we should probably talk about.

23:59But yeah, like he's at the point now

24:01where like I notice him starting to

24:04reach for Effect first to solve problems

24:06because he's seeing the value it brings.

24:09And it's so funny, every

24:11developer that I have

24:13convinced to try Effect.

24:15Ends up falling in love with the fact

24:17even if they have no

24:19FP background.

24:21And I also don't think it's

24:24fair to categorize Effect necessarily

24:26fully as like an FP thing.

24:28And that's a disservice to what it is.

24:31And I think these people I'm thinking

24:32about on Twitter or other people I just

24:34know tangentially that

24:34have tried Effect like.

24:36They don't know or they don't care that

24:37there's underlying FP

24:39foundations. Same for React. Right.

24:42React tricked the entire world into using

24:47functional programming

24:48principles and concepts.

24:49I would like to hear more about like

24:51those anecdotes I now with the

24:54benefit of time have like seen quite a

24:58few of like those of conversion cycles.

25:00And I think every time it sort of like

25:03goes in like a bigger splash radius gets

25:06bigger and like some like you are very

25:08notable example for that.

25:10I think you've been also like you had

25:11also your phase of being skeptical.

25:13And then over time, you saw more

25:16where the value is.

25:17But I think also maybe it was a good time

25:20to talk a bit more about like your

25:22own transition from like

25:24initially being skeptical to like what

25:26were the things that

25:27like made a click for you.

25:28And I think maybe it's similar for some

25:30people. Maybe it's dissimilar because

25:33like you obviously saw the you know

25:35already what better programming paradigms

25:39and like practices are.

25:41So maybe you didn't need to be convinced

25:43about those. Those are those probably had

25:45like validity for you in the first place.

25:48But maybe you wouldn't

25:50like what gave you pause.

25:52So what gave me pause upfront.

25:54Was obviously syntax it's weird to

25:57see the first time but I

25:59had also gotten to a point.

26:01Maybe a maturity as a developer were like

26:04OCaml looks weird like if you look at

26:06OCaml it doesn't look like anything

26:08you've ever written ever because there's

26:09no parentheses or brackets or anything.

26:12But in my experience writing OCaml like.

26:14Someone learning OCaml gets past that in

26:16two to three days. So like I've learned

26:19to set aside like if I have a knee jerk

26:21reaction because of syntax I set that

26:24aside regardless of the

26:25language or ecosystem now.

26:27I've, I don't know through experience

26:29have just come to recognize that it

26:31does matter for adoption but it doesn't

26:33matter as much as we think it does.

26:37I think some people refer

26:38to it as Tailwind Effect.

26:40Yeah exactly.

26:42So initially skeptical of the syntax. I was like

26:45When I first started trying it

26:47I was skeptical because like I was that

26:48over eager young dad that made a mess

26:50with Ramda. I have worked in and cleaned

26:52up through consulting

26:53large RxJS code bases.

26:56So like, going into Effect I was like

26:58this ain't it. This isn't going to work.

27:00But because I recognize some of those

27:03patterns from Go and Elixir and OCaml.

27:05I was like I want to

27:07give this a real shot.

27:08And like almost immediately day one it's

27:11just like the syntax kind of just melt

27:13away you realize that it's not that

27:16different at all like looking at.

27:19all of our Effect at Vercel.

27:21It looks so close to regular TypeScript

27:25like the only things that.

27:26Look kind of distinctly different is

27:29like setting up our layers like

27:31that is the piece that.

27:33Ends up not looking like.

27:34What you're used to in the JavaScript or

27:36TypeScript ecosystem and even then that's

27:38the kind of thing that takes.

27:39One or two days you see the pattern over

27:42and over again and

27:43it's like okay I get it.

27:44But like for all of our

27:45business logic like it.

27:47Really just looks like normal TypeScript

27:49and every dev I've showed that doesn't

27:51know Effect can read our code and

27:53understand what's

27:54going on very very quickly.

27:55Despite everyone

27:56saying that is not the case.

27:57So I had that same experience right so

28:00the first thing one of the things I built

28:02to learn a new language or

28:04stack is I like building a.

28:06Basically the OAuth flow for

28:08Spotify and like pulling playlists.

28:11So that looks like I'm doing the whole of

28:13flow launching a browser spinning up a

28:14temporary HTTP server hitting the call

28:17back and I did that.

28:19That was the first thing I built with

28:20Effect and immediately I was

28:23like oh this makes sense like.

28:25Just I got introduced to the platform

28:27package very early I got introduced to

28:30like a bunch of the concurrency

28:32primitives like deferreds or mailboxes.

28:34The error handling obviously is always there

28:38in front of you you're forced to deal

28:39with it and it's just like within writing

28:42a couple hundred lines

28:43of Effect I was like.

28:44This feels good this feels like.

28:48There's something here and then you just

28:50kind of keep going and as you need

28:52different parts of the ecosystem you pull

28:54it in and you keep having these.

28:56Kind of like oh this gets better and

28:58better and it all just.

29:00Is designed in mind with each other so it

29:02composes together from the error handling

29:04to the tracing with Otel to.

29:07Schemas much like Zod and

29:10It ends up making you more productive and

29:12able to develop faster and develop way

29:14higher quality software faster.

29:16So I love the example that you keep going

29:19back to when you try out a new technology

29:21or a new language and more

29:23comprehensive technology.

29:24you didn't

29:25need to learn what concurrency is you

29:27didn't need to learn like what are

29:29handling is when http server like you knew

29:31a lot about those concepts and so on like

29:33you had a strong intuition for those.

29:34Yet I guess if you've all done that on

29:37one day there you need to like learn

29:40about the surface area and quite a bit of

29:42the surface area of

29:43Effect there in one day.

29:45And presumably you didn't have another

29:47Dillon there who's already up and running

29:49with Effect he says like don't worry

29:50don't worry like yes looks like quite a

29:53bit but like it's very simple like just

29:55over here you do that

29:56over there you do that.

29:57You did that presumably all by yourself

29:59so what help you to kind of like not

30:03get lost in the big forest and that you

30:06basically could take it one step at a

30:08time and what advice would you give to

30:10people who might feel a sense of being

30:12overwhelmed by Effect

30:14being very comprehensive.

30:15Yeah so there was definitely overwhelmed

30:18with like you type Effect dot and you

30:20just see the whole API and your lsp offer

30:23docs and there's a lot

30:24there but if you just.

30:25focus on doing the task at

30:27hand, I think, and only taking the pieces

30:30that are obvious that you need.

30:32It's a relatively straight forward path,

30:37especially if you are an experienced

30:38developer like I think Effect would be

30:40really hard to learn.

30:42Just like right off the rip for a junior

30:43gym like I don't think that's very

30:45different than like if you threw somebody

30:46into Go standard library and

30:48say go build the same things.

30:49But like if you have any amount of

30:52experience like building stuff like we

30:54talked about like it you'll have.

30:56The natural inclination to know what to

30:58look for I guess

31:01that just comes with experience.

31:03But just like onboarding like it's so

31:06this is another thing that I don't think

31:08we do a great job at talking about or

31:10advertising or teaching or

31:11documenting is that like.

31:12It is so easy to integrate Effect into

31:16existing code bases and it's

31:18also very easy to integrate.

31:21Effect well the other way around right

31:23like you can incorporate it into a sync

31:26await code very easily and then you can

31:29also take Effect code and use it in a

31:31sync await very easily it's not

31:33like this problem where like.

31:34It doesn't force Effect on the rest of your

31:37code base like you can isolate it to.

31:39One function a couple lines of code in a

31:41function and you can kind of control how

31:44you want to start

31:45leveraging it over time and it never.

31:49Really has this forcing function that I

31:51think people seem to think it will where

31:53it's like this all encompassing like all

31:55or nothing framework.

31:56we have like

31:57a one great example we have a internal

32:00RPC client that hits one of our

32:02domain services that we use in our back

32:04office and it's all built with Effect

32:06under the covers it uses Effect RPC but

32:09we have a really thin maybe.

32:1250 lines of code wrapper around that that

32:16puts in a sync await interface in front of

32:18it so anyone can use it and it feels like

32:20promises or it is promises

32:22so it doesn't have this like.

32:23Life over your code base you think

32:26it would it's very easy to

32:28incrementally adopt and

32:29likewise, if you build out like a service

32:32or even an endpoint or even just a little

32:34client or function and you don't like it.

32:36You can constrain it there it's not like

32:38you're stuck with it, but

32:40I have never seen someone start using Effect

32:42and not want to keep using it.

32:44Yeah, I think that there's a couple of

32:47interesting points to remark there maybe

32:50one is that given that JavaScript has

32:53been around for such a long time we have

32:55like seen many waves of like different

32:58frameworks different kind of like

32:59approaches falling like becoming

33:03mainstream and then falling out of favor again

33:06and I think every time when that happened.

33:08like the JavaScript ecosystem at large

33:11has formed like the equivalent of an

33:14immune system and forms like antibodies

33:16of like OK oh like that looks like that

33:19thing and we had a bad experience with us

33:21and it's kind of like it's rarely like

33:24wears off and it all just like compounds

33:27in skepticism and like raises the bar

33:30which is great but I think

33:32Also for some ideas that maybe look a

33:34little bit like this but are different

33:36now have a hard time to kind of get

33:38through and so I think it's also

33:40worthwhile to dispel a couple of myths

33:43about Effect to like

33:45notably about like RxJS and so on.

33:48We'll come to that in a second, but I

33:50just want to highlight again like how

33:52like I think the perception of like oh

33:54Effect is not easy to

33:56incrementally adopt.

33:57That I think is also a big myth because

34:00it's one of the easiest technologies to

34:02incrementally adopt like it's easier to I

34:05still remember when like promises were

34:08introduced to JavaScript and you had to

34:10basically go from like just call back

34:13hell to promises and you didn't have

34:15promises right away but you actually like

34:18you had to go through like well

34:20generators you had to go like through

34:22like generators through bubble etc.

34:25And now when you started introducing that

34:28that had like also ripple effects for

34:30your entire code base also still when you

34:33now when promises are even top level

34:36support top level await is supported

34:39everywhere now you do like one async

34:41function anywhere and you have that

34:43function coloring problem.

34:44So that's one aspect where I think

34:46incremental adoption is like very very

34:49difficult or another one would be if you

34:52want to interface with another language

34:54so if you want to use ReScript or if you

34:57want to use PureScript

34:59or one of those things.

35:00Then you have like your whole tool thing

35:02you need to like generate some code you

35:04need to do like something that's really

35:06like actually like FFI and so with

35:10Effect it couldn't be

35:11simpler right so you have like.

35:13You have your effect and you run it as a

35:15promise or you have your run it you have

35:17your promise and you run it as an effect

35:19like simple one liner yeah.

35:22Well Malte who's the CTO at Vercel

35:25recently had some like.

35:27Apprehensions to us using Effect and like

35:29some of the points he brought up is like

35:30well we need to be sure we're making

35:32using like everyone's using our auth and

35:34rate limiting and permission checks and I

35:37was like Malte like we're using all of

35:39this stuff like we're using it the same

35:40as everybody else it's just.

35:42TypeScript like we're

35:43just wrapping it in like

35:46Try catch effectively and wrapping it in

35:48our own values it really truly is just

35:51TypeScript we don't have some extra

35:54compilation phase we don't have that FFI

35:57layer where you have to write bindings to

35:58JavaScript functions you just.

35:59Call JavaScript functions because it is

36:01JavaScript and like I said

36:04The weirdness of the syntax goes away in

36:07literally a day or two and it becomes so

36:09easy to read it becomes easier to read

36:11than your typical TypeScript code bases.

36:15Just because of the

36:15structure it enforces on you.

36:17Yeah I don't know how to teach that or

36:20get that light bulb moment to people

36:21earlier but it once people get it it's

36:25yeah it's a beautiful thing and I think

36:27it like just becomes easier over time

36:30like we've already formed that nucleus of

36:32critical mass were first a small amount

36:35of people it has clicks and that has led

36:37to a larger group of people who it has

36:39clicked for and now like

36:41larger educators like Matt Pocock

36:45For example have also like there it also

36:47like you saw a clear trajectory like it

36:50was exposed to Effect and like didn't

36:52quite get it yet and I think then you

36:53have to really like hit the right problem

36:56then you realize okay I still remember

36:58like someone said

37:00Effect this problem okay.

37:02Let me give it a try what is this and

37:05like it's sort of like this meme where it

37:07were like you first reaction like.

37:11I was living for Matt Pocock's journey

37:15through Effect because like you know

37:17people I mean I was tagging him I was

37:20encouraging him to check it out for like

37:21the past year and a half and slowly bit

37:23by bit like he and I had some

37:25conversations about never throw he found

37:26value in never throw and he started using

37:29that and it's like

37:30As soon as I knew he found value in

37:32never throw I was like the minute he

37:34tries Effect like for something real it's

37:37game over ant then over the past couple

37:39months on Twitter you saw him diving.

37:41Day by day tweet by tweet into the

37:44different aspects of Effect and sure

37:47enough it had hooked

37:49him and he had the same.

37:52The same roller coaster ride is all of us

37:53is where it's like I just looks like

37:55overkill like a lot and it looks weird I

37:58don't know I'm fine just using a result

38:01type from another library and then you're

38:02like oh no this actually does

38:04bring some model things that.

38:07Actually are very easy to use despite

38:10what your gut reaction might be to them.

38:12So given that you have your number

38:15of dead bodies under the rug from the

38:17past of all it like introducing Ramda

38:19somewhere RxJS and I'm not sure whether

38:21you've like used Redux

38:22Saga at some point.

38:25I loved Redux Saga. So maybe we can talk

38:28briefly about each of those technologies

38:30since I hear them like every time when

38:33like a more notable person brings up

38:35Effect there's guaranteed a group of

38:38people who say like oh this is just RxJS

38:40over again or like some a smaller

38:42group of people remember about Ramda.

38:44And so like someone has like their past

38:47experience like their trauma from the

38:50past and now like matches is on top of

38:53Effect so maybe we can go through the

38:55most notable ones here and like maybe

38:58talk about like the commonalities and

39:01talk about like where

39:02they're very very different.

39:03Yeah totally done.

39:05So let's start with with RxJS

39:08probably the biggest one here.

39:09given you've used it in the

39:10past maybe we can talk about where RxJS

39:14and Effect is similar like spoiler

39:18alert both are both have a thing for

39:21streams are just as exclusively about

39:23streams. Effect has amongst many other

39:26things streams and

39:28where they're different.

39:29So I think I've I've already given

39:31spoiled the tldr but maybe

39:32you can go more into depth.

39:34So like RxJS almost has the same problem

39:38as like a sync await like it's almost has

39:42a function coloring property of its own

39:43where it forces streams and observables

39:46on you and if you want to get all the

39:49benefits from you know Rx you have to

39:53percolate that everywhere.

39:54And there's kind of like a jarring cutoff

39:56point where you get

39:57outside of Rx.

39:59I think the

39:59pipe operator we have is like one of the

40:02things that people immediately see and

40:03just make the assumption that.

40:05Like Effect is just streams and

40:06observables the whole way down just like

40:08RxJS does which couldn't be further from

40:11the truth like type is literally just

40:13function application in our case.

40:16Which is something you know it's funny if

40:19we would have gotten like a pipe operator

40:21in JavaScript like I don't think this

40:23would be a problem at

40:24all but here we are.

40:25Effect

40:26almost causes like the exact opposite

40:28thing almost like we were talking about

40:30earlier like you don't have one you

40:32literally don't have function coloring

40:33because you can treat asynchronous

40:35programming and synchronous

40:37programming as the same thing.

40:38But because it integrates so seamlessly.

40:41With a sync await like that cut off line

40:45or integrated incrementally or getting

40:47the full benefit of Effect is really easy

40:50to do in these

40:51isolated chunks where RxJS

40:53That's not necessarily true certainly you

40:54can do that but

40:56you're just using for observables

40:57and streams where Effect is giving you

41:00all these other benefits whether it's.

41:03Data structures built in or rate limiting

41:05or structure concurrency or dependency

41:09injection like there's a lot more there I

41:11think people just see dot pipe and.

41:13Make an assumption there.

41:15So maybe if we want to lean a little bit

41:17into the argument where people say like

41:20it's just RxJS all over again let's

41:23let's imagine like four years ago they

41:25were very excited about RxJS maybe

41:27they were the person

41:28in a team who is like.

41:30Tried us out over over the weekend it

41:32made some problems that were notoriously

41:34tricky very elegant with streams and

41:37maybe the thing that they've been working

41:39on was like very stream oriented and like

41:42you could actually live that dream

41:44that like hey everything is a stream.

41:46But at some point reality caught up and

41:49not everything is a stream some things

41:51got more more difficult and then they had

41:54to rip it out they had a very hard time.

41:56And when you know say like hey it's like

41:59they have that RxJS trauma and

42:02they think like Effect will

42:04be that like all over again.

42:05I think their skepticism is coming from

42:08the right place but where Effect is very

42:11very different is like

42:13if RxJS was only like a tiny sliver of

42:16Effect and you didn't have all the other

42:18pieces sure that means like if

42:20you have a different problem.

42:22you don't have an

42:23elegant solution for that but Effect has

42:25kind of like thought that through in all

42:28different perspectives in all different

42:30directions. RxJS is like

42:31this narrow tunnel of

42:33problems that it makes.

42:35Super nice to solve with and elegant to

42:38solve with and can certainly be the right

42:41solution but like Effect like I call it a

42:44standard library like missing standard

42:45library for Effect like

42:48I like to compare it to working in Golang

42:50because when you're working in Golang you

42:52very seldomly have to reach for like

42:55third party packages because.

42:57What you need is probably going to be in

43:00the standard library with a really well

43:02designed interface and API and it's just

43:05there to use it's easy to use it matches

43:07the semantics of Go and the best patterns

43:10in Go and it just works.

43:12And like if you try to view that part with

43:14RX you're going to just run into a whole

43:16headache and make these kind of very

43:18spaghetti code very messy abstraction

43:21type things trying to force.

43:22RX to be this general purpose thing

43:24because it's distinctly not and it

43:27shouldn't be but

43:28Effect is, Effect has the.

43:32You know prefix tree it

43:33has the rate limiter.

43:35It has like any HTTP RPC like it's all

43:38there it has database interfaces it has.

43:42file system to work across Bun, Deno, the

43:45browser like it's all there and it's all

43:47designed to feel the same way and work

43:49the same way so like once you paid the

43:51small learning curve price of the two or

43:55three baby four patterns

43:56that you haven't seen before.

43:58It's all the same. So basically

44:00to react generously to the it's RxJS all over

44:04again I would say yes,

44:06but this time it works.

44:07And in that regard that the dream that

44:09people got excited about RxJS

44:11initially this time it actually

44:13works with like let's see in hindsight

44:15like let's say in 10 years.

44:17new technology comes along people say

44:19Effect all over again, but I'm pretty

44:21confident that Effect will fulfill the

44:25promises that we have here.

44:26Maybe briefly to cover Ramda for the

44:29people who used it in the past I think

44:31Ramda is like has a different shape so

44:34instead of like being like super like

44:37being like RxJS as like one very narrow

44:39but like super elegant long thing

44:42Ramda has rather been like.

44:44a much smaller scope much more like you

44:48had to really like buy into the buy into

44:51the philosophy is like much more of like

44:53hey like functional programming like

44:56we'll bring functional programming to

44:58JavaScript to TypeScript and will

45:00like if you buy into that everything will get better.

45:03But I think it's kind of suffered a

45:04little bit from like the how Haskell is

45:07impractical in that regard once you want

45:09to do a real world

45:10thing like the spotify.

45:12auth thing and you're like oh well well

45:15in that consideration you need to do

45:17something impure so what was your

45:20experience back then how would you

45:22compare it to Effect.

45:23Yeah It requires the commitment to

45:26functional programming that Effect does not.

45:29Like Ramda I will say is functional

45:32programming in like just its essence

45:35Effect is not Effect like they're like I

45:39said there are certainly definitely

45:40things in Effect and patterns that are

45:43inspired by functional

45:44programming but like honestly.

45:46there are almost just as many

45:48OOP things in Effect as well like i'm

45:51writing more classes than I

45:52ever have with Effect right.

45:54So I think that's an misconception is

45:56just that like a bunch of the underlying

45:58ideas in functional programming make

46:01really good foundations for abstractions.

46:03That can scale and are easy to use and

46:06can expose maybe imperative interfaces

46:09right like this has been

46:10a popular idea for years.

46:12functional core imperative shell right

46:14and like that is like the essence of

46:16Effect like you can do that you can have

46:18your cake and eat it to here.

46:20Where with Ramda it truly is like you

46:22have to buy into understanding like

46:25monads and applicatives and

46:27how all of this stuff works.

46:29And that.

46:30It's very present to you in the code when

46:33you use it and that's very jarring

46:36encountering code like that in a code

46:39base if you've never seen it where.

46:42Like you almost have to.

46:44Learn the mental model to be effective

46:47and like while there is some mental model

46:50shift in Effect it's.

46:52Not a that far of a departure from just a

46:55sync await and regular JavaScript.

46:58And I think the best thing about

46:59acquiring that mental model is like I

47:03call it a time like pain driven when you

47:05have a particular problem.

47:07Then and maybe it's true however you

47:09realize what the solution is to a problem

47:11maybe through a more experienced

47:13colleague or a friend or through an AI

47:17agent or however you realize OK here's a

47:19problem diagnosis and here's secure.

47:22Once you realize OK the cure the solution

47:25is shaped this way then like maybe you

47:28like take the solution term.

47:30Whatever structure concurrency typescript

47:34and just start googling that or ask Chat GPT

47:37and then you already have an a

47:41mental model for what you want.

47:42And if you have that mental model you

47:44have your problem you have your solution

47:46mental model and then you start using it

47:49everything just fits

47:50like a glove.

47:51And I think that is the the best starting

47:55point to adopt Effect like have a real

47:58problem that's really annoying that is

48:00like actually like business level like

48:03meaningful and then that makes it

48:05worthwhile I think that makes it for the

48:06best argument also to your colleagues

48:09that like taking the

48:10risk might be worth it.

48:12So maybe with that segue let's spend a

48:15few more minutes before we come

48:17to a close about like some of the

48:20superpowers that Effect has

48:22unlocked for you at Vercel.

48:24Yeah I think one of the biggest ones

48:25is telemetry like all of our services at

48:30Vercel have like pretty

48:31decent telemetry with data dog.

48:33But our team in our

48:35service is in particular have.

48:37Distributed tracing just working like we

48:39can see traces from our front end RPC or

48:43HTTP clients down through the HTTP layer

48:46into the services into our data access

48:48layers if we kick off.

48:50You know asynchronous jobs on like a job

48:52queue or a workflow or something we can

48:54connect the traces over

48:55there very easily so we just.

48:58Get this easier picture of how our

49:01systems relate how the data flows makes

49:03debugging so much easier so like

49:04observability out of the box is like just

49:07a huge unlock with

49:08Effect. Other thing is

49:10for our domain search in particular we

49:13are doing a lot of optimizations around.

49:17Making it really fast that require kind of more complicated.

49:22Concurrency patterns

49:23and caching patterns and.

49:25The tools we need are just there with

49:27Effect like we would have to be bringing

49:31in at least half a dozen

49:34external libraries to be.

49:36Kind of managing these same solutions and

49:39implementations and with Effect it's just

49:42a couple lines of code and it just

49:43you said fits like a glove and like that

49:45like not only is that great for

49:47productivity and like consistency of code

49:51across a code base but it also like.

49:53You went back to like I don't know when

49:55you said this earlier but wanted fitting

49:57like a glove and like when you land on

49:59like an elegant solution that it just

50:01feels like it fits and it flows well like

50:03that feels good like that's.

50:05Like dopamine it's like you're getting

50:06dopamine kicks from that all day long

50:09writing Effect because it's just like

50:11that just worked and like it wasn't

50:14complicated was a hard and just flows

50:15correctly is like oh that it feels really

50:19really good to write Effect.

50:20Yeah, I think there the more experience I

50:23got over the years the more I kind of

50:26like also had to come to terms like okay.

50:29No things are not as as like easy and

50:31simple as I want them to be there's just

50:34like inherent like a high and like

50:36there's more complexity.

50:38And more entropy and whatever we're

50:41dealing with then we initially thought

50:43and then it comes all about like modeling

50:46it that we say like hey this entropy this

50:48complexity here we can like ignore

50:50probably not important.

50:51But that complexity those aspects those

50:54we really need to account for and then

50:57comes to basically the point of like your

50:59software tries to model like your domain.

51:02And this is where you just need to

51:04account for certain things and things how

51:07things go wrong and how things should

51:08happen at the same time how like

51:11performance looks like another thing to

51:13model for and to basically

51:15come to terms with like the.

51:17Harsh complex reality Effect is stands

51:20out in the way for you to do that but

51:23empowers you to do that and I think this

51:25is what like like lets you stay in the

51:27flow and gives you

51:28joy doing the hard work.

51:30Yeah yeah it makes doing the hard and

51:33right things first class and natural and

51:36easy the other really big unlock is I

51:40think the testing story for us.

51:42Like many large enterprise TypeScript

51:45Node code bases most of our testing

51:47framework isn't just with these kind of

51:49implicit mocks or file

51:50this is a module level mocks.

51:52But by being able to have true and real

51:55dependency injection like we're one of

51:57the few teams that has a legitimate.

51:59end to end local dev experience

52:00because we can write implementations of

52:02our interfaces against local stat or we

52:05can write a in memory client and just

52:07dependency injection for

52:08Redis so it just makes testing.

52:10So much easier I've never had a better

52:14testing or easier testing experience them

52:17with Effect so that's another thing that

52:19has been a huge unlock for us.

52:21So I think this already gives us some

52:23really concrete ideas for what we should

52:26talk about in the future since

52:28firstly you have a hard stop so we need

52:30to let you go at this point but we're

52:32already in the process of

52:34scheduling a follow up episode.

52:36Where we might also have some of your

52:38colleagues join as well maybe this is the

52:40time where we dive deeper into dependency

52:43injection into testing some of those like

52:45superpowers that Effect gives you maybe

52:47some other topics one topic that's really

52:49top of mind for me these

52:51days is like

52:52How we build with AI and how we built for

52:55AI and I think Effect is both the perfect

52:58fit for for both of those so some great

53:01topics to explore but.

53:03I need to let you go at this point, so

53:06thank you so much Dillon for coming on the

53:08show today and having such a nice

53:10conversation. Yeah Thank you for having me

53:12and i'm looking

53:13forward to the continuation.

53:15Thank you for listening to the

53:16Cause & Effect Podcast.

53:18If you've enjoyed this episode, please

53:20subscribe, leave a review

53:21and share it with your friends.

53:23If you haven't done so already, you can

53:25join our Discord community.

53:27And if you have any questions, feedback

53:29or suggestions about this episode or

53:31about Effect in general,

53:33don't hesitate to get in touch.

53:35See you in the next episode.