Datasets:
willtheorangeguy
/
2022-Go-Time-Transcripts

Dataset card Data Studio Files
xet
 Community
text
stringlengths
0
2.35k
[327.52 --> 334.98] So to me, when the tooling starts to not work for you anymore and things like that.
[335.06 --> 335.36] So, yeah.
[335.56 --> 339.58] In a nutshell, that's a little bit my definition of what legacy software is.
[339.80 --> 341.46] So you said very, very old.
[341.96 --> 343.26] So we're on Go time.
[343.72 --> 347.14] Go, to me, doesn't feel like a very old language.
[347.82 --> 353.22] So I wonder, maybe, John, I know that you've had a little bit of experience working with this,
[353.22 --> 356.70] but at what point did Go applications turn into legacy?
[357.44 --> 362.92] Well, so that's a good question because you can actually, and again, it depends on how you define legacy.
[363.22 --> 370.06] But it's, at least in our scenario, it's very possible to have fairly recent code that is suddenly legacy.
[370.06 --> 377.98] And like one example of where you might hit that is if you have a system that was implemented in a fashion that really didn't suit the need.
[378.14 --> 382.18] So you're forced into a greenfield rewrite and supporting two systems.
[382.18 --> 384.46] That's an easy definition of legacy code.
[384.58 --> 389.02] We've got a new thing that's going to do the stuff, but an old system that we have to support.
[389.28 --> 395.34] I might define legacy code as any type of code that your engineers hate to work on.
[395.34 --> 399.46] Okay, so any code that I don't want to work on, I can just say, oh, that's legacy.
[399.80 --> 401.78] It was written last week, but it was too old.
[401.82 --> 402.72] I don't want to work on it.
[404.34 --> 404.70] Okay.
[405.36 --> 410.90] And then I wonder, Jeff, specifically, I know you've kind of joined the New York Times preferably recently,
[410.90 --> 414.38] and I know that you came to a kind of legacy system.
[414.90 --> 420.78] Coming in, how do you identify whether something you're working on is legacy or not?
[420.78 --> 426.62] Is it that like everyone in the team is saying, oh, this legacy system, but are there indicators when you're kind of joining a new team,
[426.90 --> 428.88] you're like, oh, this feels legacy?
[429.42 --> 436.22] I feel like part of it is everyone just says that this portion of our services are really difficult to work with.
[436.22 --> 437.62] They're kind of considered legacy.
[438.16 --> 439.42] But I don't know.
[439.46 --> 445.70] I feel like maybe my own definition of what is legacy is kind of more broad than what's been given so far.
[445.70 --> 452.96] I think legacy is definitely something that, for me, is something that is already there by the time you joined the team, right?
[453.34 --> 455.76] Regardless of whether people like to work with it or not.
[456.30 --> 457.88] That's kind of like software itself, right?
[457.88 --> 460.24] We're building on top of what has come before us.
[460.98 --> 464.40] So I guess that would kind of be my own definition of legacy.
[465.20 --> 470.16] But I definitely take into account what other people on the team who have been working with the system have to say about it.
[470.16 --> 474.94] But our old stuff or like our old system is very difficult to work with.
[475.04 --> 478.92] It definitely informs my opinion on what I consider legacy.
[479.64 --> 480.22] Yeah, for sure.
[480.22 --> 490.12] And then obviously when we're talking about legacy, I feel like not only are we talking about legacy architecture, legacy infrastructure, but we have legacy dependencies.
[490.62 --> 496.32] I mean, a lot of our apps have hundreds possibly of external dependencies.
[496.32 --> 502.14] At what point do we and how do we go about defining our dependencies as legacy?
[502.28 --> 509.42] I don't know whether Misha, you wanted to speak a bit on kind of how do you think about dependencies and when they become legacy?
[509.88 --> 510.10] Right.
[510.22 --> 518.52] Well, so, for example, the project that I work with now, which is written in Go, it's about two years old at this point.
[518.52 --> 525.50] So probably not legacy code, strictly speaking, although there are parts of it that are starting to feel like legacy code.
[525.82 --> 528.08] We can talk about that separately later.
[528.26 --> 534.56] But yeah, as far as external dependencies that are legacy systems, we have a few of those.
[534.56 --> 548.94] The way we've dealt with them is by caching as much as possible, caching the data that's returned by the external dependencies to reduce the latency, essentially of dealing with external legacy projects.
[549.54 --> 552.38] And is that something that you do for all of your dependencies?
[553.02 --> 556.18] Or is that something you kind of have a specific list?
[556.52 --> 557.84] Or like, how do you make that decision?
[558.22 --> 563.80] So on our team, we made those decisions specifically based on our latency metrics.
[563.80 --> 571.40] So it doesn't really matter whether the external dependency was written in Go or Java or what have you.
[571.52 --> 576.70] If we feel like we need to optimize for latency, we try to cache it.
[577.10 --> 578.22] That's with our approach.
[578.86 --> 582.58] So yeah, monitoring and testing for latency in this case.
[583.10 --> 583.80] For sure.
[584.24 --> 592.94] And then obviously, when we're talking about legacy in its many different definitions, because, you know, as we kind of can tell from even these initial definitions,
[592.94 --> 601.50] there is kind of a fluid way of defining, we can't just identify and then say, great, we're going to rebuild, refactor.
[602.12 --> 608.14] We have to maintain it, whether it be for a month, a year, many, many years.
[608.14 --> 619.80] So I'd love to hear a little bit about what it is like, both from like a day to day, personal, but also from a technical point of view to maintain legacy code.
[620.20 --> 625.16] And I know kind of Chris, our wonderful co-host has been kind of spearheading a maintenance series.
[625.16 --> 629.80] So I know this really tees into the various different topics you've been exploring.
[630.30 --> 639.02] Perhaps for our listeners who aren't fully familiar, I'd love to kind of pass over to you, Chris, before we dive in to talk a little bit about like how we've been exploring and thinking about maintenance.
[639.84 --> 649.66] Yeah, I guess I would start with saying my view of maintenance is definitely not, I think, in some ways as maybe negative as everybody else seems to think it is.
[649.66 --> 654.38] Like when I hear the term legacy, I think there is this kind of this feeling of dread that a lot of us have.
[654.46 --> 659.96] But, you know, the term legacy can actually be a good thing, too, like the legacy that you leave from the life that you lived and things like that.
[660.00 --> 663.92] And I kind of take the same view that I take for something like debt.
[664.16 --> 667.64] It's like there's good debt, there's bad debt, there's good legacy, there's bad legacy.
[668.14 --> 672.72] And I think that really informs the way that I also see legacy when it comes to code.
[672.78 --> 675.82] I kind of see it's like anything that's hit production to me is legacy, right?
[675.82 --> 679.54] Like it's out there, it's something you have to deal with, it's something that we have to maintain.
[679.66 --> 684.48] And we have to understand, even if we don't necessarily like that code at the end of the day.
[684.64 --> 692.86] So I think like before it gets to production, when you can still change it and mold it and do what you like with it, I think at that point, yeah, we're still dealing with something that's not legacy.
[692.98 --> 694.16] It's not debt yet.
[694.40 --> 697.38] It's not something that like we have to necessarily deal with in the future.
[697.58 --> 701.68] But once it hits production, once it's out there, it becomes very difficult for us to pull back.
[701.84 --> 705.68] Now, of course, we can get into the semantics of what does it mean when something actually gets to production.
[705.96 --> 709.16] But I think that's like the way that I at least conceptualize this.
[709.16 --> 715.18] So I think pulling it further back than anybody else has and really seeing it as like, well, all of our code is legacy.
[715.46 --> 720.66] And it really comes down to like, which code do we think is good legacy and which code do we think is bad legacy?
[721.40 --> 724.94] Well, yes, I really like what I'm hearing so far.
[724.94 --> 734.08] One thing that jumped to my mind is, to me, a Go code base, even though it might not have been designed the proper way or whatnot, it's still easier to refactor.
[734.26 --> 739.10] It's still easier to change the status of the code base.
[739.10 --> 741.98] Because there's probably unit tests and whatnot.
[742.10 --> 746.92] There is probably lots of tests in a modern code base.
[747.48 --> 754.86] So to me, I understand all of this, but I feel it might not be the same thing here.
[754.86 --> 763.72] When you're stuck with something and, yeah, you don't have anything, anything, no documentation, no tests to exit yourself out of this situation.
[764.02 --> 766.58] Because like you said, I really like what you said.
[766.66 --> 767.34] Everything is legacy.
[767.52 --> 768.42] Yeah, I understand that.
[768.42 --> 775.54] But it seems to be that when the budget is there and when the team is there, you still have option.
[775.86 --> 784.66] Whereas I work at small companies that they just cannot invest into any kind of refactor or even a rewrite at that.
[785.14 --> 787.98] So you still have to maintain the code base.
[788.30 --> 794.10] Yeah, and I think that's definitionally just bad code at the end of the day, like if you can't maintain it in any way.
[794.10 --> 799.94] But I would also say I've run into lots of circumstances where we have lots of tests and they're not good.
[800.06 --> 801.48] They give us a false sense of confidence.
[801.70 --> 804.40] Or you have lots of tests and they're written in the wrong way.
[804.46 --> 809.04] So whenever you touch something of the code base, you have to go refactor a few hundred lines of tests.
[809.60 --> 814.68] So I think even in your example there, it's like, yeah, no, tests definitely can make a code base better.
[815.16 --> 817.38] And generally they show the mark of a better code base.