Choosing the Right TypeScript Migration Strategy with Yann Cabon

Joe chats with Yann about the different TypeScript migration strategies and how to overcome the steep learning curve in the early stages of migration.

Show Notes

Yann is a principal software developer at ArcGIS. He joined the JavaScript team in 2012/2013 and began a large TypeScript migration soon after. Since the project was always on the back burner, it took his team a while to migrate over half a million lines of code.

He states that one of the major benefits of using TypeScript is the ease of refactoring, making the code highly scalable.

Yann mentions that the ArcGIS data API has become much faster and more streamlined since the migration. When asked if this negatively affected the consumer in any way, he responds with a confident no.

Yann also discusses how the process has become much simpler over time compared to the steeper learning curve in the early stages of migration. He said that now, any time a new feature needs to be released, they opt to release it in TypeScript every time, bypassing further migrations.


[00:00:00] Yann Cabon: I'm Jan Ca. I've been working, I'm a principal software development engineer at ri. I joined the company 10 years ago. I'm from France and then I was basically in France after school. I was working with, I was doing flash development and I really loved the interactivity, working with interactivity, animations and stuff on the web, and I.

[00:00:25] Yann Cabon: Came to work on the project that was working with maps and it make it take a serious. of A applied topic, but then still very interactive. And I really enjoyed that. And yeah, I was working with product there, and then I joined the company afterwards and moved to the us.

[00:00:40] Yann Cabon: So I was doing flash development and of course the flash decline. And we had three APIs. We had the Flash Flex api, JavaScript API and silver light api. So of course like just JavaScript survived and. And yeah, so I joined the JavaScript team like in 20 12, 20 13. And we did a big [00:01:00] migration afterwards to type script.

[00:01:01] Yann Cabon: So yeah. Do you want, I can talk a little bit about the project maybe?

[00:01:06] Joe Previte: Yeah, maybe before we do that, for anyone who's not familiar what is Esri? Yes.

[00:01:11] Yann Cabon: Esri is a world leading company to produce that makes applications to work with gis. So GIS is a geographic information system, so it's an information system, so database and so on, but then where your data may have Geographic information, right?

[00:01:27] Yann Cabon: So it could be an address, could be shapes, like point lines, polygons could be satellite imagery. And it's very, it's used everywhere. It's used in your local city to calculate your or your county to calculate your tax. It's used by all the industries to To, to, I don't know, like retail store.

[00:01:44] Yann Cabon: Like where do I place my next retail store? So I know which what is my I know which who is coming to my store. So maybe I will look at the demographics of the us look at the income, and then determine mine okay, maybe I should place my next store here used by like to monitor the pandemic it's [00:02:00] used to Yeah.

[00:02:00] Yann Cabon: All different kinds of use cases. And so RI produces a lot of apps to do that. And then we have D step apps. It's an app desktop, d step apps, mobile apps, and of course the web. As we exist for F 50 years. So it's been it's been it's been there for a while doing this.

[00:02:18] Yann Cabon: And then on the web we have ri as a developer project, the one I'm working on, and then also apps that they are building on top of that developer project for specific use cases and industries.

[00:02:31] Joe Previte: Awesome. Okay. And, sorry, last thing about you before we get into it. Where in the US are you based?

[00:02:37] Joe Previte: So

[00:02:37] Yann Cabon: I'm based in Redlands, California. It's between Los Angeles and Palm Springs

[00:02:44] Joe Previte: around. Oh, okay. Yeah. So Southern Park. Yeah.

[00:02:46] Yann Cabon: Yeah, East of Philly. It's like an hour. We have an hour and a half from. Yeah.

[00:02:51] Joe Previte: Okay. Cool, cool. Wow, so 50 years. Okay. That's crazy. Yeah. So from, Yeah. Well, Let's get

[00:02:56] Yann Cabon: And private company the founder still owns and still who, owns [00:03:00] Okay.

[00:03:00] Yann Cabon: And works at the company. So yeah. Yeah.

[00:03:03] Joe Previte: Wow. That's crazy. Okay. Yeah. Let's get into it. Let's get into the project. Yeah. Wherever. Where do you think we should.

[00:03:12] Yann Cabon: Yeah the way so the data is hosted, your your data may be hosted on on that, in, in the cloud or on databases that you have in your own infrastructure.

[00:03:21] Yann Cabon: And then we have. RI as servers that lets you query the data, but especially, so you can query data, by, give me all the features, all the entities that are in the specific area. And then we have so they exposed the server exposes for api. And then we have the JavaScript API that I'm working on that communicates with the server to be able to create the data on the server, display it, and then you can build data visualizations and work with the data on the client.

[00:03:50] Yann Cabon: Being able to create statistics of the data, being able to modify the data and sync it back with the server. Okay. So you can build visualization mapping visualization both in 3D [00:04:00] or, so you can build that on a globe, for example, a visualized data underground, visualize, all types of data.

[00:04:05] Yann Cabon: Yeah. Yeah.

[00:04:07] Joe Previte: Wow. Okay. How does this compare to something like Google?

[00:04:10] Yann Cabon: I would say, Google Maps, Google Earth are more towards the, their target is more like the public, right? The consumers. Okay. Us, we are building tools for what our developers to build apps for specific use cases.

[00:04:23] Yann Cabon: So it's more yeah, it's different but definitely there is some overlap. Google Maps, you can consume files called kml. That Google Maps create a Google Earth created, sorry that we can also consume. So there is a lot of overlap between all these technologies. Yeah, for sure. Okay.

[00:04:40] Joe Previte: And okay you talked a little bit about the history, right?

[00:04:43] Joe Previte: There was the Silver Light app the JavaScript, and then I'm forgetting the other one. Flex. Yeah. Flex. Oh, the Flash. Yeah. Yeah. So yeah, let's talk about the JavaScript one. At the start of this, you said, Four years let's take into that story.

[00:04:57] Yann Cabon: Yeah. When I joined I decided to start [00:05:00] working on the JavaScript api.

[00:05:01] Yann Cabon: We wanted to create a new major version for it to integrate 3d. So the idea was to integrate 3D across all the SDKs APIs that we had and all the. That s we asked. So there was a bit lot of refactoring and then as the team was rather small at that time and then it grew a lot and we had a whole lot of developers coming that work in Randy Center in Zurich.

[00:05:25] Yann Cabon: They do, they take care of everything's 3D over there, so they have a lot of background in she plus per right. And so come, they were starting also doing Java paper and for. Going from a type language to an UN type was very hard, and for us, also, Flash flex. The language behind extra script three was also very close to JavaScript, but typed it was it was like feeling natural to To to use type language.

[00:05:49] Yann Cabon: We, since it was, we already had a lot of code already in JavaScript. We couldn't, we didn't start from scratch. And also at the time it wasn't clear if type script [00:06:00] was the right choice because there was Google coming up with 80 Script and that the abandon in favor type script that we had also like Facebook with flow and so on.

[00:06:08] Yann Cabon: So we. Let the dust settle. But then, yeah, we, in 20 15, 20 20 15, we started adopting a type script. So just by converting one file at a time to work Hdn in 2020. Yeah. So yeah, For five years. Yeah,

[00:06:25] Joe Previte: for five years. Okay. So before we get into that part I wanted just to ask who. So you had the c plus developers come in, right?

[00:06:33] Joe Previte: They're from a, a typed language development environment, right? They come in, they're like, What is this JavaScript and then the action script side as well. Who was the one that said championed this and said let's use this typed language.

[00:06:43] Yann Cabon: It was it ku, like we were.

[00:06:47] Yann Cabon: A bunch of us, like maybe three or four of us were monitoring the pole guys of type script. And then and then yeah, when he made sense, yeah, we just decided collectively there was no we don't have someone that dictates those kind of rules. [00:07:00] So yeah, it's I think, yeah, it made sense for our, a lot of us.

[00:07:03] Yann Cabon: So we we decided to jump into it.

[00:07:05] Joe Previte: So it was I. The maintainers, the development team was like, it was a unanimous agreement. Yes. Yeah. Okay. Yeah. Okay. And then the other thing that I think was interesting that I also wanna get into is, so this was back in 2015, and like you said, You, the team didn't know is type script, the right choice.

[00:07:23] Joe Previte: And you said he waited for this dust to settle. Like how did you know when to decide or when the dust was settle?

[00:07:30] Yann Cabon: Yeah, I think it's when type script was first announced, it was like maybe 0.9 or something and it was too close to us. And at the time, Microsoft was not as cool as it is today.

[00:07:40] Yann Cabon: And yeah, and Google was coming up with 80 scripts it's Yeah, we waited for just to have a clear picture that Okay. Type script was, was ITing really fast adding features all the time. And yeah. It and there is not so much competition after that Yeah.

[00:07:54] Yann Cabon: Yeah.

[00:07:55] Joe Previte: That's why. Yeah. That makes sense. Yeah, cuz I ask [00:08:00] because I would say, at the time of recording this podcast like it's. What is it? May May, 2022. Yeah, it feels. The obvious choices type scripts, at least in my mind. But I imagine maybe there'll be another time where a team is deciding, Oh, do we choose type script or this new thing that came up, right?

[00:08:20] Joe Previte: So I'm, That's why I was asking like, how did you know to make that decision?

[00:08:25] Yann Cabon: I have to say it's been a while. , no. Also, I think, type script is very much like very close also to, to to action script. And it was also very, it's very close to JavaScript in. Yeah. And Yeah, no, I think, yeah, it just made sense,

[00:08:37] Joe Previte: Yeah. And it seems five years later, I'm sure the team is happy with the decision. Yeah,

[00:08:42] Yann Cabon: Yeah. No, definitely. Yeah, for sure. We're not going back. , , right?

[00:08:46] Joe Previte: Yeah. Cool. Now let's, now I think it'd be interesting for us to get into the migration strategy because I've had, at this point I've had maybe three or four other people on, and there's different strategies you can take.

[00:08:57] Joe Previte: So maybe you can walk us through the [00:09:00] strategy that you chose.

[00:09:00] Yann Cabon: So yeah, the project is has it's pretty large. Today we have I, I checked the stats today. We have 3000 fives just the code base not the tests. It's overall of half a million lines of code in not included documentation.

[00:09:11] Yann Cabon: So it's quite big. So the thing is what was important for us is that we. Every three months, we release four times a year. Big version. And when we release the JavaScript API or, and also all the apps that are built with the JavaScript. So we can't we can't just go in a summary mode for six months, nine months to convert the entire code base.

[00:09:33] Yann Cabon: We need to keep releasing. And also, migrating to that trip is not something very important from a product standpoint. It's not adding really much a new feature. It adds. Other benefits being able to AI faster and and implement features faster. But, from a project management perspective, it's not very interesting.

[00:09:50] Yann Cabon: So every change we, we made, we had to make it at the beginning of a release and especially the major, when we. We're converting big chunks.

[00:10:00] Or even like upgrading from a version of type script to another. We have to do that at the beginning of a release cycle. So that's why we had to split it up over over, over time we didn't really have upfront clear plan because yeah, it's just just we had to just go through it, at the same time Cript was also a tool for us to organize our, how we deliver the api. The API was built on top of the DO toolkit at long time ago. And the DO toolkit is you create. Modules in AMD in S five and those modules, they don't play well with any build tools like with Webpac or with Ular or with any C out there.

[00:10:43] Yann Cabon: So we had to work a work around all of this with a duct tape. So the idea was to migrate, to tap strip, but also to deliver modules at the. That could be consumed everywhere without any extra tooling or plugins and so on, because we are just a library. We are not like a, we are not a framework.

[00:10:59] Yann Cabon: We [00:11:00] are a big library, but still, so was a way so that once you converted everything to , you can choose, what is your target. Then, with further bill tools, you can produce different outputs. So we started from AMD ES five modules on incompatible, and now our API is fully ESM es modules that you can just NPM install.

[00:11:21] Yann Cabon: And then the main benefit is that, yeah, you get in your app at the most tailored, I guess call that will be used and it's the build tool that takes care of it. The inconvenient is that. Nothing is right. So the modules so the build tool will have to process this part of it is prebuilt, but overall not so much.

[00:11:39] Yann Cabon: And yeah, so that trick also helped on so delivering the modules and also get, remove progressively the use of Dojo across the cut base. Okay. Yeah. Yeah. So yeah, it took us some time. took us some time.

[00:11:55] Joe Previte: Yeah. Five, the, when you gave us the stats about the code base, I it's huge.

[00:11:58] Joe Previte: How. [00:12:00] Yeah, can you talk like how big's the team? Like why do you think it took a long time? Did it feel like a long time?

[00:12:06] Yann Cabon: Yeah. Yeah. So at the same time we were also, at the same time we were migrating to touch script, we were also adding more features. And migrating to touch script was also always back on the back burn now.

[00:12:17] Yann Cabon: So we had to do a lot of this, there was some planning to remove more of the big The big chunks of DRO that we were using. For example, we wanted to make DRO as a poem implementation, right? But we wanted to use the native poem that is, that exists in JavaScript. As soon as they were, they became available into JavaScript, into the language.

[00:12:37] Yann Cabon: We used type script to. Just create an interface of of the promise instead of we couldn't use the promise. We were using the D Promise, which has an API close to promise, but has extra functions. So we represented that that promise implementation with our own interface and then progressively where he.

[00:12:55] Yann Cabon: We now down this interface to to just arrive to a [00:13:00] point where our interface was matching the policy interface and we were able to migrate like this. But these projects, like as we were converting code to that way, we also had to take care of all this migration on the way. So that's why it took, Yeah, I took it, it took so much time.

[00:13:16] Yann Cabon: So yeah. Yeah,

[00:13:19] Joe Previte: man. And how many people are on the team? I think we

[00:13:23] Yann Cabon: are like 30 yeah, 30, 40, something like that. I don't have the final count. .

[00:13:28] Joe Previte: So that's, they were all helping with this migration?

[00:13:31] Yann Cabon: Yes. So some of the project we manage, smaller projects, we managed to, split up the work across across the repairs that were more like familiar with pieces of the code.

[00:13:40] Yann Cabon: But then, yeah, we couldn't disturb so the regular, implementations of new features from the next release. So yeah little by litter some releases. We we converted more some releases we converted nothing. We got stuck also on some versions of of tight script for longer time.

[00:13:55] Yann Cabon: For example we were stack for on 3.3 for maybe. [00:14:00] Nine months because we were using type trip in a way that was not very good. And then 3.4 stopped allowing us to do that. So we had to yeah, to to fix certain stuff we were doing before. Basically just in short, djo or load you, you to create classes with multiple super.

[00:14:19] Yann Cabon: So you add but it was, so now you can do that in text reviews in Mixings. But Oh, okay. Our, yeah, our, the way it was done before that was we had a function that was mixing in all those super classes. Into one and then yeah, ri didn't really like that's in text anymore, so yeah. .

[00:14:38] Joe Previte: So you had to find a work around or guess do it the proper way?

[00:14:41] Yann Cabon: Yeah. Yeah. So now we have better, I think, at this following the release schedule of of type script, the release right before us. So we come to really be always at the same version, but usually when we start the next cycle, we just upgrade. And and just fix the, fix the breaking changes and, but it's.

[00:14:56] Yann Cabon: We are cruising on this now. It's fine. Yeah.

[00:14:59] Joe Previte: [00:15:00] That, that's awesome. And so obviously that's been a long journey and a long process and, we've talked about some of the difficulties of migrating, but what are some of the benefits you've seen from migrating?

[00:15:12] Yann Cabon: Yeah. So today the benefits is that, The benefit, of course, is refactoring, right?

[00:15:18] Yann Cabon: We have to display lots of data on the map, like maybe a million record and really fast for the user. So you you architect, you design your. Your code so that it it would take care of x amount of use cases, but then after you have more use cases coming in or more more type of data coming in, and now you have to, you can.

[00:15:41] Yann Cabon: Keep adding features to your code, but then your code get more complicated and at some point you need to rethink a little bit your design and come back a little bit. And and then yeah, when you have to move all your pieces of code around, like that really helps. And then just, navigating the code being able to look at the what code or [00:16:00] references, what code and what are the implementation of the interfaces and so on.

[00:16:04] Yann Cabon: So that that, yeah, definitely really. . , all these

[00:16:06] Joe Previte: parts. So I guess the big ones to summarize, like refactoring documentation Anything else?

[00:16:13] Yann Cabon: Yeah, no, that's the, Yeah, mostly why, what, Yeah.

[00:16:16] Joe Previte: And you were talking about writing features, right? And it, you would you agree that it helps you ship more confidently?

[00:16:22] Yann Cabon: Yes, for sure. After, we still have extensive test suites. But but yeah, it's like adding a new feature because we use, for example, union types to represent multiple types of data that you can add. As soon as we want to add the new data type automatically the compiler will notify you, Hey, you probably need to support this new data type in this part and this part.

[00:16:40] Yann Cabon: Yeah. Yeah, it helps yeah. In all these aspects. Yeah. Yeah. .

[00:16:44] Joe Previte: And you completed this migration. Did you celebrate

[00:16:49] Yann Cabon: It felt like a big void in me. Like I dedicated so, so much time. I was like, okay, what do I do now? I was doing all of stuff, but it was, yeah, I was taking a lot of my of my time.

[00:16:59] Yann Cabon: [00:17:00] So yeah, no, it's just went onto another release and then also we finished that, joined the pandemic. Celebration was a me. During the down, Ah, shoot,

[00:17:10] Joe Previte: shoot, shoot. Okay. That's awesome. That's crazy. I That's It's a long, that's a long time.

[00:17:14] Yann Cabon: Yeah, it's a long time. But yeah, no, it's great.

[00:17:16] Yann Cabon: Now we are almost like two cutting edge. Before it was hard to consume our our modules because of bilities. Now you can consume our ES modules, but then now it's like the build tools that have to improve to be faster and consume our stuff better. But we are like really using the, all the latest JavaScript features and yeah, no, that's, Pretty awesome.

[00:17:39] Joe Previte: Yeah. I wanna know like from the user's standpoint, right? Cuz like this is a library that we're talking about. So developers are consuming it, Has migrating to type script affected them in any way?

[00:17:50] Yann Cabon: No. So what we did also is so the way the migration, okay, so our library, we, when we don't use type trip to generate the declaration [00:18:00] files, we use our documentation.

[00:18:02] Yann Cabon: To generate the dec, the declaration files because we were we were publishing the library on MPM and we wanted to have declaration files on at types. And since everything was not on type script we couldn't. Do that from type script. So the way the, basically the way we migrate is that we had all the JavaScript files.

[00:18:21] Yann Cabon: We just converted one, just reaming the file to type script. And then the j we had the JS doc embedded inside the each of these modules. So when you convert your file to that trip, you still buy ability to, to JavaScript. So the GS doc would would be, would carry over. And and we created a custom JS doc template to process the JS doc the JS do object model to generate back after dts.

[00:18:48] Yann Cabon: Our typings they are not perfect. They don't, we don't, the typings don't support our generics and stuff, but but yeah, it works. So going back to your question there was no disruption, I guess with developers, like developers that [00:19:00] used to use the API in a way before that can continue to do that.

[00:19:03] Yann Cabon: But now we just have a new way, which is like consuming ES modules and and they share the same typings and yeah, no, it's pretty much the.

[00:19:11] Joe Previte: Okay, so to summarize if I'm understanding so it was JS before I would consume it, I might see a little bit of like intelligence.

[00:19:18] Joe Previte: Not very much. You migrated to type script now when it imported, I see like the return type the perimeter types, things like that. And then the third step was like adding JS doc. So I get all of the type script stuff, but I get maybe like an explanation from the doc.

[00:19:33] Yann Cabon: Yeah. No. Yeah. So we when JS doc passes our our JavaScript files that we generate it from type trip JS doc has, Ah, yeah.

[00:19:42] Yann Cabon: So JSD creates its own object model and then we gen form that object model. We generate back declaration files, and in the declaration file we embed a little bit or self digest doc so that when you do, when you have the, in inte sensee, you get a little bit of the doc, a link to the doc page. J [00:20:00] from the Interen vs.

[00:20:01] Yann Cabon: Group for number.

[00:20:02] Joe Previte: Wow. Okay. So written in type script generates JavaScript. Yeah, the JavaScript and as the,

[00:20:12] Yann Cabon: Yeah, the JavaScript as the JS doc and the typing. And the Doc. .

[00:20:17] Joe Previte: And the doc. And then obviously when MPM install you MPM install the types two. Yeah. Which gives you, access to that declaration file and all the types.

[00:20:25] Joe Previte: Okay. Got it. Wow. That's really cool. Yeah, because

[00:20:28] Yann Cabon: we didn't have since the project was not. Type trip from the start. Yeah, we couldn't we couldn't generate the definitions fired from them. We had JavaScript, so that's that was the reason and type dog didn't exist at the time, so we were like going with Gs dog and yeah, that was it.

[00:20:43] Joe Previte: So in the beginning, before it was migrated to type. You've provided types, is that right? Like types?

[00:20:51] Yann Cabon: No, it came along the way. I don't remember exactly when, but Okay. Yeah, we came by being generated from the dog. Yeah.

[00:20:57] Joe Previte: Got it. Okay. [00:21:00] And did you get any feedback from the users after you added JS Doc?

[00:21:04] Yann Cabon: No, not really. Just, I guess it just works. So when you walk, no one tells you , but yeah, I know. It's yeah, it's it, yeah, it works. Eventually, like the advantage of from generating from the doc is that our typings match what is publicly documented, right? So if we don't document a function it won't appear in inside the typings either.

[00:21:23] Yann Cabon: So that's pretty

[00:21:23] Joe Previte: cool. That's really great. Yeah, that's, So your docs are always up to date.

[00:21:27] Yann Cabon: And the typings are following the doc. So if someone reports a typing issue in our documentation, then after they are also, that issue is also the typing. So when we fix the doc, just just match the problem is like we have to maintain the JS doc and the typings.

[00:21:43] Yann Cabon: The JS doc defines what typings will be in the final. Typings if that makes sense. So if the doc has an issue in in in the written type that you document, then it'll also be in the final typings.

[00:21:55] Joe Previte: Yeah. But the JS doc is the source of truth? Yes.

[00:21:58] Joe Previte: Yeah. [00:22:00] That's really cool. Okay. Huh? That's a really, that's a really cool. Yeah.

[00:22:07] Yann Cabon: As hopefully at some point we would be able to toe I think more truthful typings directly from the source code, so maybe , using the compiler I api we could Go through go through the code base only document what has JS doc JS doc comments for something like that, going from there.

[00:22:25] Yann Cabon: But it's it's, again, it's a project that doesn't, you know, that we require a lot of effort and and we have already a solution that works. So for now we are keeping this.

[00:22:34] Joe Previte: No, that totally makes sense. And since you've, done this whole migration has there been positive feedback or acknowledgement from like the greater organization?

[00:22:45] Yann Cabon: Yeah, so the typings are are we generate daily bills of of our NPM package that are publicly available. And this work, like we've also the typings of course, and so yeah, our. The other projects that this three that chose to use type script, they can [00:23:00] consume uh, consume the, those new features, click with the right typing.

[00:23:03] Yann Cabon: So definitely helps them also , because sometimes the doc might, might be too crude at somewhere at the beginning. And yeah, I think the typing's ready, really helps them like not making, the, typing mistake basically.

[00:23:14] Joe Previte: Exactly. So then they can use the product and like the library better and build a better app.

[00:23:18] Joe Previte: Okay. Yeah, I ask because, like five years is a long time and so I'm imagining if someone's listening to this and they're at an organization, they're trying to get buy in for type script I guess what advice do you.

[00:23:33] Yann Cabon: I just do it. That's, it's working. . Yeah. No, it's yeah, for us, it took us a long time just because of our, schedule.

[00:23:40] Yann Cabon: Just trying to. One file at a time. It works to be able to ma mix and match type script and Java files and compiling in the same folder. It does work. It just, yeah, it just, the amount of code that we have to, that we had to part that made that but. What we did, of course, as soon as we introduced s like every new feature was in touch with, so we [00:24:00] weren't, we were never going backward. It was just like moving the legacy PCs back to to touch. That took us more time. Yeah.

[00:24:08] Joe Previte: And one thing we didn't touch on that, now that you say that I wanted to bring it up, is what, like how did you. Decide did you build time into your sprints where it was like, Hey, if you have extra time, go migrate this file.

[00:24:24] Yann Cabon: Yeah, it was more like this. It's we had a list of we knew like what needed to be parted and then and then as soon as, someone, a lit little bit of time, just to convert a simple class. Just anything that could help. And then sometimes for the bigger effort, we had to do a little bit more organization.

[00:24:41] Yann Cabon: For example, the, this poor mis migration we had to organize a little bit more like what needed to happen first and then second and then after split it across developers and in general it was taking like maybe one day off work. So it's not too much and when it's splitted across everybody.

[00:24:56] Yann Cabon: So yeah, this is how we did. .

[00:24:59] Joe Previte: And was [00:25:00] it easy for the team to adopt type scripts?

[00:25:03] Yann Cabon: Yeah, I think, yeah, type script has a steeper long income, especially like when you deal with complex types. But yeah, yeah, I think overall, like even people that start contributing now that don't have too much experience with that, they since we have so much code already in the code base, they can like look into existing stuff and and get.

[00:25:22] Yann Cabon: Get it walking, think . Yeah. And we also use the link and there is a bunch of stuff that, how to fixed and uh, so it's, I think it's much simpler now that it used to be. Yeah.

[00:25:34] Joe Previte: Yeah. So people can get onboarded quickly, learn from the patterns of the code base cuz it's so large and

[00:25:39] Yann Cabon: be effective.

[00:25:40] Yann Cabon: And we are also more to be able to help, if I,

[00:25:42] Joe Previte: yeah. And what about, I'd be curious, like when you add, when you hire people for the team, do you look for type script experience?

[00:25:48] Yann Cabon: No, not really. Just just being being curious I think is is important after I think it's fine.

[00:25:54] Yann Cabon: You can learn a, if you have a lit, having no, definitely having JavaScript experience. But now you hear more and more [00:26:00] developers that we hire, that they have tried they have tried Java type script so yeah. It's hard to find like developers that have worked on such a, like larger code basis.

[00:26:10] Yann Cabon: But but yeah, as soon as, as long as you did some JavaScript, it's, pretty Okay.

[00:26:15] Joe Previte: Yeah, cuz yeah. Some of the more complex stuff like you into generics and things like that can be cut tough. But the other stuff, like you can, with that many people, with that much experience, you can ramp up quickly.

[00:26:24] Joe Previte: Yeah, definitely. Is there anything else that you want to talk about that I haven't asked about yet? Yeah, I,

[00:26:29] Yann Cabon: I can just mention how inside the rest of of Sri so yeah. Type script. We don't have a, we don't have a company policy to use type strip every, so each team is free to use JavaScript type however they want.

[00:26:42] Yann Cabon: The program with these different projects, like sometimes they want to contribute back something they include to our project. Three require conversion and cocha is a bit complicated. So couple years ago we started we started a project to create web components that we can share which is also building types of using a stem.[00:27:00]

[00:27:01] Joe Previte: Oh, okay. STL gs. Okay. Yeah.

[00:27:03] Yann Cabon: Yeah. So it's called Case Site. It's our design system. It's a suite of like right now they are like 50 50 UI components. All the controls like that you can think of, the buttons and the trees and whatever you can put and they are distributed as web components so all the apps now can actually share.

[00:27:20] Yann Cabon: More more common code. And I have a consistent design across all the apps, across the the company. And then we will probably create another project later on to have like more use case focus, like more complex components that that implement full workflows instead of just some like the simple controls.

[00:27:36] Yann Cabon: So yeah, so that's that. And it's, it gets a lot of traction, a lots of people contributing to that project which is which is pretty cool to see. Yeah.

[00:27:44] Joe Previte: That's awesome. So it was like you started with JavaScript. You might go to the type script, and now type script is kind of part of your default stack, right?

[00:27:52] Joe Previte: Yeah. More and more. That's awesome. And you said, what was the name of the design system?

[00:27:57] Yann Cabon: It's called Cal Site. Cal site. Cal site. [00:28:00] Okay. Yeah. I can send you a URL at

[00:28:02] Joe Previte: some point. Yeah. We can put that in the show notes. And that's open source?

[00:28:05] Yann Cabon: Yes, it's open source. There is some licensing to be able to use it, but the code is is a source.

[00:28:10] Yann Cabon: Cool.

[00:28:11] Joe Previte: Yeah. And just outta curiosity, What cuz one of the things that some people talk about when they have an open source code base and they're thinking about migrating to type script, you know I've heard people say in the past like, Oh, I'm afraid that's going to limit the number of people that can contribute cuz it requires type script.

[00:28:31] Joe Previte: What do you think

[00:28:32] Yann Cabon: about that? So my project is not open source project. So we didn't really, we didn't really have this issue And yeah, it's like what is important is how your team is comfortable. I feel and if the team think that the team will be more productive moving forward, I think it's a very important point to consider.

[00:28:50] Yann Cabon: . Yeah, ForSight for the care side components, for example, it wast, it was part of stencil. Stencil, was was built on top of type script. It made sense to yeah, to work the key there [00:29:00] in type.

[00:29:01] Joe Previte: Yeah, that makes sense. When you're working with a tool, it's already in type script, like Yeah, go with go with the flow, yeah. Cool. I think that's all the questions that I got. Where can people go to find out more about Esri and, find out more about your work?

[00:29:18] Yann Cabon: Yeah our website is js. So RRGs is the suite of of apps and servers and everything. So, you're gonna get access to our sdk being able to, post the different capabilities, examples, visualization that you can make.

[00:29:35] Yann Cabon: Yeah, I think in the components, they are on GitHub. They're also on the developer website on that same website, so we can learn about this as well.

[00:29:45] Joe Previte: Sweet. And we will we'll make sure to include links to both of those in the show notes so that people can find those easily.

[00:29:51] Yann Cabon: Yeah, for sure.

[00:29:52] Yann Cabon: You can p me also on Twitter. I'm on Twitter for a long time, so you know, I'm happy to ask reply to [00:30:00] answer more questions there.

[00:30:02] Joe Previte: Cool. And we'll drop a link to your Twitter as well. Cool. Y thank you so much for joining us today. This was super insightful. Yeah, I think, and. We'll see you around.

[00:30:11] Yann Cabon: Yeah. Thank you, Joel.