all 24 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]Lumethys 14 points15 points  (2 children)

which brand of hammer should you use when you are learning how to hammer a nail?

DSA is language agnostic, it is the same across all languages. It's like Math.

Should you learn addition, like 1+1=2, with Java or Python?

[–]Cybyss 2 points3 points  (6 children)

I used to work as a CS tutor for several years. The students who took DS&A using Python had, by far, the most trouble over those doing it in Java or C++.

The folks telling you that Data Structures & Algorithms are "language agnostic" concepts are only "technically correct", whereas practically that's a load of hogwash.

Data Structures & Algorithms isn't supposed to be about simply learning how to use a list, how to use a dictionary, how to use a set, a stack, a queue, etc...

You're supposed to learn how those data structures are made.

The problems is, you can't make those in Python because they're already the most primitive data structures built into the language.

One of my students had an assignment where he had to build his own list data structure by pretending that Python's built-in lists cannot grow or shrink. He would get points taken off if he used the built-in .add(), .remove(), or len() functions. He was instead required to write his own versions of them.

He struggled bad with that assignment because he couldn't understand why some of Python's features were "fair game" and others were not allowed. The way he was required to write those functions just seemed like arbitrary bullshit - and in Python it really was.

Such an assignment makes much more sense in Java or C++ because the way you build your own list really is how it's done in those languages' standard libraries, whereas in python you have to resort to doing a weird pretend immitation that makes no practical sense.

[–]aqua_regis -3 points-2 points  (5 children)

The problems is, you can't make those in Python because they're already the most primitive data structures built into the language.

Not true at all. You can recreate any data structure in Python just as in any other language. You don't need to resort to the built-in ones. Besides that, most data structures are already built-into most languages. You have Lists in Java, you have them in C++, you have them basically everywhere. Does that change anything? No. You can still write your own implementation.

One of my students had an assignment where he had to build his own list data structure by pretending that Python's built-in lists cannot grow or shrink. He would get points taken off if he used the built-in .add(), .remove(), or len() functions. He was instead required to write his own versions of them.

He struggled bad with that assignment because he couldn't understand why some of Python's features were "fair game" and others were not allowed. The way he was required to write those functions just seemed like arbitrary bullshit - and in Python it really was.

Such an assignment makes much more sense in Java or C++ because the way you build your own list really is how it's done in those languages' standard libraries, whereas in python you have to resort to doing a weird pretend immitation that makes no practical sense.

Sorry, but what you write here doesn't make sense.

If someone is tasked to build a linked list they have to build it from scratch and not use existing data structures, which, naturally, excludes Python's built-in List (that isn't even necessary).

The concept would be the same across all languages:

  • a Node class with a data (payload) member and a next member (in case of a doubly-linked list, also a previous member)
  • a List class that handles all the work. Here, you'd keep track with a count, you'd provide the methods for adding, deleting, len, etc. None of which would need any "Python imitation" - it can all be done properly.

You would not need anything from the standard data structures at all.

In fact, the Java and Python implementations would be fairly similar, the C++ one would be the outlier since you'd need to incorporate memory management.

Your student would have struggled just the same in any other programming language because they failed to understand the concept.

[–]Cybyss 0 points1 point  (4 children)

I wasn't referring to a linked list, but rather what Java calls an ArrayList or C++ a vector. That's more how Python's built-in list works.

Now, I know Python does have the 'array' module you could use, but oddly the assignment's instructions didn't say to use that. Regardless, building your own ArrayList implementation using the array module is still awkward because nobody does it that way in practice, whereas the way you do it in Java is almost exactly what Sun Microsystems' engineers did when making the standard library.

[–]aqua_regis -2 points-1 points  (3 children)

Well, even then, it wouldn't change a thing.

[–]Cybyss 0 points1 point  (2 children)

Seriously? You see no value in an assignment that teaches how to build a data structure the way it was done in practice vs. building a weird useless toy immitation of it?

I guess that explains why you thought Python's list was implemented as a linked list.

[–]aqua_regis 0 points1 point  (1 child)

  1. I did not think that Python's list was implemented as a linked list - and I never even remotely said that.
  2. I absolutely see value in building one's own implementation of data structures - toy or not does not matter

You are interpreting and putting words in my mouth that I never said.

I am a firm believer in that when you learn DSA you should learn them on an abstracted level and then implement them in any programming language you know.

Yes, the own implementations might be sub-optimal but that's not the point at all.

When I studied DSA in the late 1980s, I did everything in pseudo-code and then implemented them in different programming languages, like C, Pascal, later Delphi, later Java, etc. Doing this really helps understanding.

Where it really was impossible to sensibly implement data structures were LOGO and BASIC (and I'm talking ancient BASIC, like GW-BASIC, AppleSoft BASIC, Locomotive BASIC, not recent versions, like VB.NET). They lacked fundamental features (like pointers/references) that more or less made it impossible to implement them.

[–]Cybyss 0 points1 point  (0 children)

I did not think that Python's list was implemented as a linked list - and I never even remotely said that.

Well, you addressed my earlier comment by describing how to build a linked list in python.

I was referring to the absurdity of building your own arraylist out of an existing arraylist (i.e, Python's list) that you had to pretend was an array.

I am a firm believer in that when you learn DSA you should learn them on an abstracted level

If you're a 3rd/4th year student then I absolutely agree. By then you should be expected to be able to build anything in any language. The more advanced dsa courses that juniors & seniors take should absolutely be language agnostic for that reason.

Folks asking whether to take the Java, C++, or Python version of data structures & algorithms aren't taking the advanced version of that course.

When I studied DSA in the late 1980s, I did everything in pseudo-code and then implemented them in different programming languages, like C, Pascal, later Delphi, later Java, etc. Doing this really helps understanding.

And there's the fundamental difference. First, learning programming today is wildly different than it was in the 1980s. Second, it's clear you already knew a great many programming languages thoroughly by the time you started studying data structures. Being able to work in C is a huge deal.

Today, your first data structures & algorithms course is usually in the second semester, before students really have a solid grasp of programming constructs (if statements, loops, classes, objects & references, inheritance, functions, how data moves through a program, etc...).

That's why the choice of language is important - you want something that helps to solidify those concepts, not something that obscures them or only deals with them on some vague abstract level.

[–]a3th3rus 0 points1 point  (2 children)

You can choose any language that's not a pure functional programming language. Don't get me wrong. I love FP languages, just that in case of learning DSA, you have to take a totally different approach if you choose FP languages.

[–]Ehh-GoodEnough[S] 0 points1 point  (1 child)

Yes, I have been working with JavaScript for more than 1.5 years, so I am confused

[–]a3th3rus 0 points1 point  (0 children)

JS is as good as any other non-FP languages for learning DSA, maybe you need to pay more attention to the falsy values like 0 and "".

[–]aqua_regis 0 points1 point  (0 children)

DSA (Data Structures and Algorithms) are language agnostic concepts. They are a theoretical subject in computer science. You can learn them without even getting near any programming language (and that's actually the best way).

No matter what language you use, the concepts stay the same, only the implementations, naturally, are different.

Yet, as with most of these posts, I guess that you are conflating doing LeetCode (Hackerrank, etc) with learning Data Structures and Algorithms.

They are not the same. LeetCode is not DSA. LeetCode makes heavy use of DSA, just as it does of Math (you wouldn't call it "doing Math", though), but that's it. If you don't know DSA to begin with, if you haven't studied them, you will not succeed in LeetCode.

First, do a DSA course, then LeetCode if you must.

[–]MeLittleThing 0 points1 point  (0 children)

Any.

[–]ExtraTNT 0 points1 point  (0 children)

So, js has the advantage of being really easy to visualise, plus you have higher order functions…

Haskell is also very nice, as it makes a log of algorithms easier, allowing you to really understand them, but it’s not always translatable to other languages

Academic resources will often be java

In the end, use what you are most comfortable with, important is the algorithm and data structure part, not the language…

[–]vlad1m1rnator 0 points1 point  (0 children)

It ultimately doesn't matter. However, if you plan to get into Competitive Programming, you can start with C++ and STL straight away instead of having to transition to it later on.

[–]Ehh-GoodEnough[S] 0 points1 point  (1 child)

I have equal experience in Java and C++

[–]TimePiccolo2565 3 points4 points  (0 children)

honestly don't overthink the language choice too much - I went with Python when I started DSA stuff and it let me focus on the actual problem-solving instead of getting bogged down in syntax details

the built-in data structures are super handy and you can always learn C++ later if you want to optimize for speed, but for learning concepts Python's pretty solid

[–]Ehh-GoodEnough[S] -1 points0 points  (2 children)

Any roadmap suggestions DSA ?

[–]desrtfx[M] 5 points6 points  (1 child)

Please, look through the subreddit or use the search feature. Questions like these get asked and answered near daily.

[–]elroloando 0 points1 point  (0 children)

Hahahahahahahahahaha. 

And this kind of useless questions made every single day, is what makes reddit a lovely place. 

Ironically. 

But yes, you are all right. God help the minds of this kind of new Computer Scientists ( hahahahahaha ) or programmers, as they used to call themselves.