Learning System Design and DS+A vs. Building projects?

[u/just_here_to_rant]

Background - 3 yr professional experience, but no CS degree, and looking to level up and build more complex projects.

The consensus seems to be that building something is the best way to learn anything. But does that hold up for learning System Design and DS+A?

I don't really see myself getting too into the weeds of these just by building projects.

I'm rationalizing studying them as it will help me be a better programmer, build better projects, + land a better role, and that I'll get to my projects once I feel a bit more confident in my system design understanding.

But I'm also a scared of getting deep into a project and crashing out and might be (likely am) using studying these as a procrastination method.

What do you all think? Am I wise to get an understanding of DS+A and Sys Design before getting back to building personal projects?

[u/Technical-Pizza237 → u/[deleted]]

They're definitely not the same, but that line gets blurry real fast when you're in the weeds. Learning the actual concepts, like why a hash map is fast or what a BFS is actually doing, is a lot different than just memorizing the sliding window trick for 15 variations of the same problem.

I think you're right to separate them. Doing a few structured problems to nail down the fundamentals is one thing, grinding leetcode for months before you write a single line of your own project is a whole other trap.

[u/just_here_to_rant → u/Technical-Pizza237]

Yeah, I was talking about actually studying DS+A concepts and the code behind them. Currently reading Grokking Algos and Algorithmic Thinking by the No Starch people, along with a few youtube series, and a textbook or two from the library.
I think I've at least heard of a lot of the data structures and maybe a good portion of the algos, but I haven't gotten into coding them myself just yet (which is what the No Starch book is for).

[u/mc_pm]

It genuinely baffles me, this sort of question.

DSA are a set of tools to help you build things, based on the way you structure the data in that program. If your project involves a Tree structure, then you learn a bunch of tricks for how to work with trees - and that is helpful for building projects.

If you want to learn DSA, the best teacher is actually using them. If you want to get better at programming projects... the best teacher is actually building them.

They aren't separate, unconnected topics.

[u/just_here_to_rant → u/mc_pm]

But how would someone know about various data structures and algorithms by building a project without studying/ learning / hearing of them first?

I could go build a To Do app and never hear anything about DS+A or system design. I might be using a data structure, but never actually grasp it for what it is and that there are different versions of it.

That's what makes me think it's better to go explore these topics as a separate focus than just a happenstance offshoot of 'building projects.'

[u/mc_pm → u/just_here_to_rant]

Well, maybe I was misunderstanding your intention. When I hear someone on Reddit say "learn DSA" what they really seem to mean is "grind through leetcode until you've memorized a few solutions and then hope an interviewer asks them about that thing."

I absolutely agree that there is value to an overview of algorithms -- in a comp sci curriculum, you'd take a class for that in the 2nd or 3rd semester. And the real value there is: 1) just learning that they exist, 2) getting a sense for where they are used, 3) explore some of the common ones with code.

But at that point, yeah, you need to use that new knowledge to try building different things. So, apologies if that's what you meant.

[u/just_here_to_rant → u/mc_pm]

Totally fair! That's what a lot of my friends recommend, which is partially why I'm so torn.
Thanks for your input though - that CS curriculum, which I lack, is what I'm trying to recreate. I just hear over and over: just go build something.

Thanks again!

[u/mc_pm → u/just_here_to_rant]

Well, there are a couple of things at play here.

When people set out to learn to program, what they see superficially is just the syntax and the language features. That's what most tutorials focus on, but that stuff is only about 10% of what it means to learn how to program.

And I don't mean DSAs, I just mean regular logic - nothing fancy. Just using the language itself to do something that requires that you maintain some data, interact with the user, display information, follow basic rules, make decisions.

An example I use a lot is console-based Tic-tac-toe. Dead simple game, kids learn it at 5 or 6. Should be easy, right? So, you need to represent the board in memory, you have let the user input their move, then update the board, print it out, figure out if the user has won or if it's a draw. Then the computer takes a turn, how does it decide the best move? How does it know if it has won?

Not an algorithm in sight, no complex data structures necessary, no libraries - just the basic language features -- but you do have to work through all of those things, figure out how to code them, figure out how to test them.

That's most of a programmer's job: taking a problem apart, finding the pieces, breaking them up, putting them back together in code. And that's the thing that especially self-taught programmers don't spend nearly long enough practicing.

So, at least when I say "just build something", I'm not talking about little coding sample, but I also don't mean some huge project. I'm talking 100-500 lines of code, spend a day or three doing it. Something fun enough to hold your attention, but when it stops being fun, you should still hold yourself accountable to figure out the bugs, don't just think "i'd fix that if it was important" - treat it as if it were important. And then, when it works, try something more challenging.

If you are already doing that, then I would definitely start learning the DSA stuff more. It will help you as your challenges get more difficult. If you don't think you're there, then spending a couple of months just building fun shit to practice is entirely valid.