Ufuk Kayserilioglu

And then someone at the company also built a Visual Studio Code extension to do the same thing. I think it's called Vysig. So it parses the signature blocks and then turns the opacity on. And I've actually been using it, and I'm also enjoying it because I don't necessarily need the signatures to be in front of me all the time.

And then someone at the company also built a Visual Studio Code extension to do the same thing. I think it's called Vysig. So it parses the signature blocks and then turns the opacity on. And I've actually been using it, and I'm also enjoying it because I don't necessarily need the signatures to be in front of me all the time.

But apart from that, we heard that developers actually like the safety guarantees that static typing gives them as they're doing refactoring, for example. So for example, if they're removing a class or a module from the code base, they're almost guaranteed to know that when they run the static type checker, that it will complain if there's like any dangling usages of that class or module.

But apart from that, we heard that developers actually like the safety guarantees that static typing gives them as they're doing refactoring, for example. So for example, if they're removing a class or a module from the code base, they're almost guaranteed to know that when they run the static type checker, that it will complain if there's like any dangling usages of that class or module.

So they really liked those guarantees and they didn't really mind writing the signatures in the first place. And it's a really easy ramp on as well on the signature syntax. So we actually heard good things from developers on working on the code base too.

So they really liked those guarantees and they didn't really mind writing the signatures in the first place. And it's a really easy ramp on as well on the signature syntax. So we actually heard good things from developers on working on the code base too.

Yes. That's also another one of our findings. We also talked to three different teams who were working in core, and they were one of the early adopters of Sorbet in their part of the code base. So we have this componentization thing going on in our core, in our monolith, because it's a huge code base. Otherwise, it becomes mayhem.

Yes. That's also another one of our findings. We also talked to three different teams who were working in core, and they were one of the early adopters of Sorbet in their part of the code base. So we have this componentization thing going on in our core, in our monolith, because it's a huge code base. Otherwise, it becomes mayhem.

So there's these components, and some components were the early adopters of typing. So we did interviews with team members from those teams as well to understand how they felt about those early initiatives. And one of the things that we ended up hearing over and over was that adopting types led to better code design, which initially was interesting for me.

So there's these components, and some components were the early adopters of typing. So we did interviews with team members from those teams as well to understand how they felt about those early initiatives. And one of the things that we ended up hearing over and over was that adopting types led to better code design, which initially was interesting for me.

But that seems to be the biggest benefit from adopting static or gradual typing rather than runtime type safety. And so my opinion is a little bit swayed now. Because too often when we're working on simple solutions, we reach out for like these bags of values like arrays or like most of the time hashes, right? So we just like reach for a hash and then we keep passing those hashes around.

But that seems to be the biggest benefit from adopting static or gradual typing rather than runtime type safety. And so my opinion is a little bit swayed now. Because too often when we're working on simple solutions, we reach out for like these bags of values like arrays or like most of the time hashes, right? So we just like reach for a hash and then we keep passing those hashes around.

But then it's never documented what the keys are. Like if let alone if the keys are symbols or string. How many times did we assume that we could access some hash using symbols? It turns out to be that it was indexed by strings. When your code base is small, that's fine. I'm not judging anyone who's doing that. But as your code base is growing,

But then it's never documented what the keys are. Like if let alone if the keys are symbols or string. How many times did we assume that we could access some hash using symbols? It turns out to be that it was indexed by strings. When your code base is small, that's fine. I'm not judging anyone who's doing that. But as your code base is growing,

you need people to more easily onboard onto your team. And if they're fixing something and if their focus is on, let's say one method or one file, you don't want them to go hunting around seeing, oh, where's this hash actually being coming from? Where was it created initially? What are all the parameters that are in this hash? So that's not like a very efficient way of working at that scale.

you need people to more easily onboard onto your team. And if they're fixing something and if their focus is on, let's say one method or one file, you don't want them to go hunting around seeing, oh, where's this hash actually being coming from? Where was it created initially? What are all the parameters that are in this hash? So that's not like a very efficient way of working at that scale.

So at that scale, it's better to give a name to that, to turn that into something like a structure or create class for it or something to basically start using types, right? Once you turn something that was a hash into a struct or a class or a module, you give a name to it, you give a type to it. So you start using types.

So at that scale, it's better to give a name to that, to turn that into something like a structure or create class for it or something to basically start using types, right? Once you turn something that was a hash into a struct or a class or a module, you give a name to it, you give a type to it. So you start using types.

And those types actually convey more information than passing around hashes would. So it leads to actually better code design. And we've heard that over and over again from various people within the company. But it also leads to evergreen documentation as well.

And those types actually convey more information than passing around hashes would. So it leads to actually better code design. And we've heard that over and over again from various people within the company. But it also leads to evergreen documentation as well.