Latest / DevQuestions with Tim Corey / 126 Does Knowing Data Structures and Algorithms Benefit a C# Developer?

Transcript

126 Does Knowing Data Structures and Algorithms Benefit a C# Developer? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_00: Join us each episode as we tackle the questions you are asking about a career in software development, understanding the industry, and new technology.
• 0:12
  SPEAKER_00: If you're just starting out or you want to grow stronger as a developer, this is the place to get your questions answered.
• 0:19
  SPEAKER_00: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:25
  SPEAKER_02: Does knowing data structures and algorithms benefit a C developer?
• 0:31
  SPEAKER_02: Well, that's what we're going to get into in this episode of DevQuestions.
• 0:35
  SPEAKER_02: And if you have a question, go to suggestions.imtimcorey, ask it there, and hopefully you'll see your question answered on a future episode of DevQuestions.
• 0:43
  SPEAKER_02: Now, this question did come from a suggestion site, and it's one that is a pretty common one.
• 0:48
  SPEAKER_02: When you go to an interview for a developer job, you'll often hear about horror stories of having to create a linked list on a whiteboard or creating data structures and binary trees and all the rest in order to prove that you're a real developer.
• 1:06
  SPEAKER_02: So do data structures and algorithms benefit C sharp developers, or are they just an interview topic?
• 1:14
  SPEAKER_02: Well, I think the answer is yes.
• 1:15
  SPEAKER_02: Yes, they do.
• 1:17
  SPEAKER_02: And no, no, they don't.
• 1:19
  SPEAKER_02: So let's talk about what were really the heart of the matter here.
• 1:24
  SPEAKER_02: We're going to start with definitions, because these are big words, data structures and algorithms.
• 1:32
  SPEAKER_02: What does that actually mean?
• 1:33
  SPEAKER_02: Let's start with data structures.
• 1:35
  SPEAKER_02: A data structure is just a way to house data inside your language, inside C sharp, since we're using that as an example.
• 1:44
  SPEAKER_02: So a data structure could be an array, it could be a list, it could be a dictionary.
• 1:49
  SPEAKER_02: We've used these, and if you have been inside C sharp for any period of time, you've probably seen most of the things I just mentioned.
• 1:58
  SPEAKER_02: So they don't have to be really scary.
• 2:01
  SPEAKER_02: They're just a way to store data.
• 2:04
  SPEAKER_02: And yes, when you comes to interviews, they don't talk about lists or arrays.
• 2:11
  SPEAKER_02: They talk about more advanced and edge case type things.
• 2:14
  SPEAKER_02: We'll get to that.
• 2:15
  SPEAKER_02: But a data structure itself is just a way of store data or uh hold data to process it inside of C sharp.
• 2:24
  SPEAKER_02: So what's an algorithm?
• 2:26
  SPEAKER_02: An algorithm at the very core of it.
• 2:29
  SPEAKER_02: Now, there's been a lot of things added on to algorithms, but the very core of an algorithm is just a logical way to solve a problem.
• 2:39
  SPEAKER_02: It's not a necessarily a rule, it's not a even a pattern.
• 2:44
  SPEAKER_02: Patterns can be algorithms, but algorithms don't have to be patterns.
• 2:49
  SPEAKER_02: They're just a way to solve a problem.
• 2:52
  SPEAKER_02: And in software development, that's really all we're faced with is logic problems.
• 2:57
  SPEAKER_02: We're faced with, okay, I want to do this.
• 3:00
  SPEAKER_02: How do I make my code do that?
• 3:02
  SPEAKER_02: Logic.
• 3:03
  SPEAKER_02: Well, that's you create an algorithm to do that.
• 3:07
  SPEAKER_02: You create a pattern to do that.
• 3:10
  SPEAKER_02: And some of these things we have kind of defined into design patterns where we say, okay, we've seen this problem often enough, and we have solved it with an algorithm multiple times.
• 3:25
  SPEAKER_02: We've looked at those algorithms and said they're all kind of similar because similar problem, similar solution for the most part.
• 3:33
  SPEAKER_02: And so we've kind of boiled it down to, oh, let's create a design pattern that will kind of encapsulate our thoughts on the best ways to solve a problem like this generically.
• 3:47
  SPEAKER_02: So I have a generic problem like this.
• 3:49
  SPEAKER_02: Here is the general idea of how you would solve it.
• 3:53
  SPEAKER_02: And that's where we kind of mix in design patterns and principles into algorithms.
• 4:00
  SPEAKER_02: But an algorithm is just a way to solve a problem.
• 4:04
  SPEAKER_02: And it's it can be unique to your specific situation.
• 4:08
  SPEAKER_02: So that's what design patterns are, I'm sorry, that's what data structures and algorithms are.
• 4:14
  SPEAKER_02: That's not really that scary, right?
• 4:16
  SPEAKER_02: It's just a way to work with data and work with your application and how to work with the logic of your application.
• 4:23
  SPEAKER_02: And when it comes to evaluating a person's ability to perform the software development role, it kind of makes sense.
• 4:32
  SPEAKER_02: Do you know how to work with data?
• 4:34
  SPEAKER_02: And do you know how to work with logic?
• 4:37
  SPEAKER_02: That makes total sense.
• 4:39
  SPEAKER_02: And so from that perspective, yes, you should absolutely know data structures and know how to work with and create algorithms.
• 4:49
  SPEAKER_02: This is where things get off the rails a bit, though.
• 4:53
  SPEAKER_02: So a lot of things are simple.
• 4:56
  SPEAKER_02: Okay.
• 4:56
  SPEAKER_02: And actually with.NET, uh.NET Core even and.NET 6 and beyond, things got even easier when it comes to working with our data structures.
• 5:09
  SPEAKER_02: Because we've got a lot of great data structures, and really for most cases, the data structure is a pretty common one.
• 5:20
  SPEAKER_02: We'll use a list or we'll use an I enumerable, but that's a pretty common one to use, and we don't necessarily have to deviate from that standard type.
• 5:29
  SPEAKER_02: Maybe if we have a certain use case come up, we'll use a dictionary.
• 5:34
  SPEAKER_02: Or they're all generic and they just work.
• 5:37
  SPEAKER_02: And maybe we work with an array once in a while, but not often, because we have the generic list.
• 5:43
  SPEAKER_02: So we don't have to deal with too many decisions on the data structure side, because most of those things are really performance, and it's only in the very, very edge cases where we have to make good decisions about one specific type versus another specific type.
• 6:03
  SPEAKER_02: I'm not saying you shouldn't know more, but really for a junior developer, a mid-level developer, even up to almost a senior developer, you don't have to worry about it that much.
• 6:15
  SPEAKER_02: It's only when you get into those really edge cases where you start to think, yeah, maybe I should figure out how to optimize or micro optimize this because I'm doing it 100,000 times.
• 6:25
  SPEAKER_02: And a micro optimization becomes a macro output value, macro improvement.
• 6:31
  SPEAKER_02: So we don't normally have to deal with knowing too many data structures.
• 6:39
  SPEAKER_02: But that's hard to test.
• 6:40
  SPEAKER_02: It's hard to evaluate.
• 6:42
  SPEAKER_02: Hey, you know what dictionaries?
• 6:43
  SPEAKER_02: Yep, good, cool.
• 6:44
  SPEAKER_02: So is everybody else.
• 6:45
  SPEAKER_02: So how do I evaluate you?
• 6:47
  SPEAKER_02: Well, we bring in edge cases where we say, okay, how would you create a linked list?
• 6:54
  SPEAKER_02: Do you know when the last time I used a linked list was intentionally, like an actual linked list in C sharp?
• 7:00
  SPEAKER_02: I'm not sure I have.
• 7:02
  SPEAKER_02: Okay?
• 7:02
  SPEAKER_02: Because I've done lineup business applications where it wasn't really necessary.
• 7:06
  SPEAKER_02: And for the most part, list works just great.
• 7:10
  SPEAKER_02: And iEnnumerable works just great.
• 7:13
  SPEAKER_02: And the other types that I need do what I need them to do.
• 7:17
  SPEAKER_02: There is a time and a place for linked lists, and I'll probably cover that in a future video, but I don't use it that often.
• 7:26
  SPEAKER_02: So why would I need to know that for an interview?
• 7:29
  SPEAKER_02: How often do you use a linked list in your organization?
• 7:33
  SPEAKER_02: And that's one of the questions you should probably ask is, okay, first of all, there's a you should learn the five-minute version of the linked list in C sharp and know how it works and know why it works.
• 7:43
  SPEAKER_02: Sure.
• 7:44
  SPEAKER_02: And that way when you walk into the interview, you can say, here's how I'd create it.
• 7:48
  SPEAKER_02: And they say, well, how would you create a whiteboard?
• 7:50
  SPEAKER_02: Well, how often do you create code on whiteboards?
• 7:53
  SPEAKER_02: Don't you use an editor and don't you use the built-in C sharp stuff?
• 7:57
  SPEAKER_02: And really, I haven't used a linked list in, let's say, five years, but Google has the answer.
• 8:03
  SPEAKER_02: And I could just Google it and implement it once.
• 8:07
  SPEAKER_02: So they try to, some companies try to kind of get the tricky questions because they think that it gives a better um, they can see a better depth to a software developer.
• 8:21
  SPEAKER_02: What it really means is you study for the interview.
• 8:24
  SPEAKER_02: So there's a lot of things like that.
• 8:27
  SPEAKER_02: The same thing with algorithms.
• 8:28
  SPEAKER_02: You start getting into, well, do you know how to implement this design pattern?
• 8:33
  SPEAKER_02: Which again is an algorithm, but it's kind of down the road from algorithms into specific design patterns.
• 8:41
  SPEAKER_02: And so the question comes up well, should I learn design patterns?
• 8:44
  SPEAKER_02: Should I learn these algorithms that have been kind of refined and built over time?
• 8:51
  SPEAKER_02: And as a junior developer, no.
• 8:54
  SPEAKER_02: No, you shouldn't.
• 8:55
  SPEAKER_02: As a mid-level developer, yeah.
• 8:57
  SPEAKER_02: You should start to understand them.
• 8:59
  SPEAKER_02: And then by the time you're a senior developer, you should know at least what they are and generally how they work, so that if you need to implement one, you can and you can identify that situation when to.
• 9:12
  SPEAKER_02: Because here's the thing the purpose of a design pattern is to really make something less complex.
• 9:20
  SPEAKER_02: But design patterns are often very complex themselves.
• 9:23
  SPEAKER_02: So it's a complex solution to make something less complex than the solution you're putting in.
• 9:30
  SPEAKER_02: So if you're a junior developer, you're not writing complex code.
• 9:34
  SPEAKER_02: And if you're a mid-level developer, you're starting to write some complex code.
• 9:38
  SPEAKER_02: And you may write some, but you might not be writing a ton of it.
• 9:42
  SPEAKER_02: And when you are, those patterns start to reveal themselves.
• 9:47
  SPEAKER_02: And that's one of the things that people often miss is design patterns really reveal themselves because again, what's a design pattern?
• 9:54
  SPEAKER_02: It's just the kind of accumulated knowledge and boiled-down essence of a solution to a given general problem that people create algorithms for.
• 10:07
  SPEAKER_02: And you can create an algorithm to solve that same general problem and go, oh, that kind of feels like this.
• 10:15
  SPEAKER_02: And so you kind of take some of the lessons learned from those design patterns and implement them.
• 10:19
  SPEAKER_02: That's why you should at least know about them at that point.
• 10:22
  SPEAKER_02: Because design patterns are there to help you.
• 10:26
  SPEAKER_02: They're designed to bring some institutional knowledge in, some knowledge we can build on top of that help us make better decisions in our code, because we are making decisions based upon the collective knowledge of multiple developers.
• 10:45
  SPEAKER_02: So it's one of those things where if you're interviewing for a junior-level job, you really shouldn't have to know a ton about edge case data structures, and you really shouldn't have to know a ton about uh design patterns.
• 11:01
  SPEAKER_02: However, and this is the key here, you're gonna have to in order to get through certain interviews.
• 11:07
  SPEAKER_02: So what do you do?
• 11:08
  SPEAKER_02: Well, you learn the basics.
• 11:11
  SPEAKER_02: Okay?
• 11:11
  SPEAKER_02: Don't base your career on these things, but learn the basics so you can talk about them, so you can have this discussions about them, but don't decide that in order to become a junior level developer, you need to understand about linked lists, binary trees, and know about the factory pattern in C sharp.
• 11:32
  SPEAKER_02: You don't need to know all those things.
• 11:33
  SPEAKER_02: That's too much burden to start out with.
• 11:36
  SPEAKER_02: But as you grow as a developer, those things will naturally add to your skill level.
• 11:42
  SPEAKER_02: They will naturally grow your abilities, and they will naturally come into play as you grow in your experience.
• 11:50
  SPEAKER_02: So they should be an over-the-time thing as far as actually using them.
• 11:54
  SPEAKER_02: But as far as learning them in order to pass an interview, just learn enough to pass the interview.
• 11:59
  SPEAKER_02: Okay.
• 12:00
  SPEAKER_02: So concentrate on C sharp itself.
• 12:03
  SPEAKER_02: Know enough to pass an interview.
• 12:05
  SPEAKER_02: That's my encouragement to you, especially as you're starting out.
• 12:09
  SPEAKER_02: Again, as you grow as a developer, these things become more and more necessary, more and more helpful to you.
• 12:17
  SPEAKER_02: So you should continue to expand your toolbox.
• 12:22
  SPEAKER_02: Learn these things, learn how they work, learn when you might want to implement those.
• 12:27
  SPEAKER_02: And then when situations come up, you can recognize that and you can implement a data structure or a design pattern or another algorithm that helps you write better code.
• 12:39
  SPEAKER_02: But until you've written enough code to really understand that and really recognize those situations, it's not really gonna help you.
• 12:46
  SPEAKER_02: And in fact, it's gonna hurt you and discourage you.
• 12:48
  SPEAKER_02: Okay.
• 12:49
  SPEAKER_02: So should you learn design pattern, or I'm sorry, uh data structures and algorithms?
• 12:54
  SPEAKER_02: Not at first, but eventually.
• 12:57
  SPEAKER_02: And if you need them for the interview, go ahead and learn the high-level knowledge of them.
• 13:02
  SPEAKER_02: All right.
• 13:03
  SPEAKER_02: Thanks for asking the question.
• 13:04
  SPEAKER_02: If you have a question, go to the suggestion site and leave your suggestion for a future episode of DevQuestions.
• 13:10
  SPEAKER_02: Thanks for listening.
• 13:11
  SPEAKER_02: And as always, I am Tim Corey.
• 13:13
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 13:16
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 13:19
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 13:27
  SPEAKER_01: You can also send your questions to questions at IamTimcore.com.
• 13:32
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 13:39
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.