search

ossu / computer-science

🎓 Path to a free self-taught education in Computer Science!
MIT License
172.44k stars 21.77k forks source link

Flesh Out Data Structures & Algorithms #664

Closed ghost closed 4 years ago

ghost commented 4 years ago

Currently the only real data structures & algorithms course is Roughgarden's Algorithms course, which is light on data structures. It is also, according to the very popular Princeton algorithms course's FAQ on Coursera, not enough by itself and more on the mathematical side.

I would suggest adding the two Princeton courses prior to the Roughgarden course to really flesh out this fairly important bit of knowledge, or consider adding in OpenDSA (an interactive and comprehensive textbook) or Berkley's CS61B

waciumawanjohi commented 4 years ago

@Andreilg This is a good collection of high quality resources. It now falls to us to determine which are sufficient for a student. I think you would agree that not every student needs to take all 4 courses.

OSSU uses the CS2013 for curricular guidance. (A little more about that here)

CS2013 has a section on the curricular expectations of Discrete Structure instruction. (Page 77 of the doc's numbering, page 79 of the PDF) Note: the section "Core Tier-1, Core Tier-2, Elective: What These Terms Mean, What is Required" (pdf page 32) is useful for understanding the recs.

How do the recommendations in CS2013 affect your suggestion above?

ghost commented 4 years ago

@waciumawanjohi I have not taken all of these courses as of yet (I am currently going through OpenDSA and CS61B) so I am not qualified to say which fits OSSU better. I was merely presenting some other resources I think could help flesh out the current offering.

However, a safe suggestion would be the Princeton Algorithms course (Parts 1 & 2) followed by the Roughgarden course since Princeton's course is highly regarded and states itself that it is complementary with Roughgarden's.

Alaharon123 commented 4 years ago

It's worth noting that Stanford is one of the case studies in CS2013 so we can actually get some help from that. Assuming that we're trying to cover the Algorithms knowledge area here, CS 161 doesn't cover the following:

We'd need someone who's already learned Data Structures to look at MIT 6.042J to see if it picks up the slack that Stanford CS 161 is missing and if not, what material OSSU does not cover.

Alaharon123 commented 4 years ago

Alright, I've taken a close look at CS2013 and we're essentially missing a course to be equivalent to CS 106B (plus a little of CS 103, but we should be able to find a course that covers all of what we're missing in one course). The following are the CS2013 Knowledge Areas that should be covered. Three out of four are what OP is referring to.

  1. AL/Fundamental Data Structures and Algorithms (CS 161 only covers about half)
  2. AL/Basic Automata, Computability and Complexity (I don't think this is covered elsewhere in the core curriculum?)
  3. PL/Object-Oriented Programming (Programming Languages is intended to serve as reinforcement, not to teach it for the first time)
  4. SDF (Software Development Fundamentals. Everything not covered in How to Design Programs and MIT 6.0001. Much of this is what OP is referring to)

Princeton's course (by itself) isn't a good option because it assumes that you've taken a Java-based intro course rather than How to Design Programs. I don't think OpenDSA is a great option either because it's moreso intended for use as a textbook than for self-learners. I'm not sure how good it would be for the task of self-learning; it probably takes the more is better model so that instructors can pick out what they want. CS 61B seems like a good option at a glance assuming that How to Design Programs is sufficient preparation and it complements CS 161 as well as we need it to. Another option could be WPI's CS 2102 followed by Princeton's course although we still need someone to go through WPI's course and make sure it works well for self-learning. The advantage of it though is that it's actually intended to continue on from How to Design Programs and it brings those ideas into object-oriented programming. WPI operates on a quarter schedule so the course isn't as long as some other courses on the curriculum. There are probably other good options too; the primary purpose of this comment is to say that on a CS2013 level, OP is correct and we are missing a course. @waciumawanjohi Should I make a Request For Comment post?

aryzach commented 4 years ago

"Princeton's course (by itself) isn't a good option because it assumes that you've taken a Java-based intro course rather than How to Design Programs. "

I haven't take the Princeton course, but the old course we had assumed that you've programmed before from HtDP, but then throws Java code at you without teaching you anything about it. I think this approach is good, and gives people a chance to learn a language on the fly, or at least the parts that they need to know about for the given task / education goals.

Has anybody taken the princeton course to see if it is comparable to our old Software Construction class? At least comparable with how much you actually need to know Java before starting?

ola-sk commented 4 years ago

Hey, since I remember some considerations about creating along the curriculum which has not necessarily free-only courses included, I'd be interested in opinions about how something like https://www.edx.org/micromasters/ucsandiegox-algorithms-and-data-structures goes along the rest of the curriculum if one aims at more data science related knowledge of algorithms. I've copied "what you'll learn" and "syllabus" sections from all of the courses in the micromasters for a quick comparison here. Thank you in advance.

m4salah commented 4 years ago

what about Algorithm and Data structure Specialization on Coursera by UCSanDiego ?

Alaharon123 commented 4 years ago

Those appear to be alternatives to Stanford's course rather than a course to fill the gap before Stanford

m4salah commented 4 years ago

Those appear to be alternatives to Stanford's course rather than a course to fill the gap before Stanford

what is the gap exactly the prerequisite for those course and stanford course is discrete math and programming language or am i miss something ?

ola-sk commented 4 years ago

@Alaharon123 You're right. I don't know yet how or in which point does it play the role as some prerequisite to any class on algorithms or advanced data structures from MIT specifically, but there is a series of two courses on Automata, Computability, and Complexity and Computation theory from MIT.

As I have found basic data structures are taught together with introductory level algorithms in MIT's 6.006 Introduction to Algorithms. This course is the first part of a three-course sequence.

The sequence continues in 6.046J Design and Analysis of Algorithms.

The third in a sequence is 6.854J / 18.415J Advanced Algorithms

The second course in the above algorithms sequence serves as a prerequisite for the 6.851 Advanced Data Structures.

Alaharon123 commented 4 years ago

@mohamedspicer Read the whole thread

@ola-sk A required Theory of Computation course is probably more hardcore than we need. For example, Williams College is in cs2013 as an example school and they have a Theory of Computation course and it doesn't cover much of the core knowledge areas aside from this Basic Automata, Computability and Complexity. They say right after that that they're thinking they should make that course an elective and put this stuff into a new Discrete Math course alongside the rest of the curriculum for that course (although they didn't actually follow through on that, which is interesting).

6.006 does look like a course to consider to fulfill the gap this issue is about. It seems to cover a large amount of the first two of https://github.com/ossu/computer-science/issues/664#issuecomment-604053084

Alaharon123 commented 4 years ago

Gonna post another suggestion here. Going with Princeton's Algorithms course, we could replace Intro CS with Princeton's Computer Science: Programming with a Purpose and Computer Science: Algorithms, Theory, and Machines as a prerequisite.

Pros:

Cons:

ghost commented 4 years ago
  1. AL/Basic Automata, Computability and Complexity (I don't think this is covered elsewhere in the core curriculum?)

This is covered in Theory of Computation in OSSU already. As an aside, I've gone through a decent chunk of those videos and I much prefer Theory of Computation from Professor Harry Porter (yes, that's his name). I can vouch for his quality in pretty much all of his videos, he's a goldmine of information. He also goes through the Sipser book in the same order so he's basically a much better version of the book.

I don't think OpenDSA is a great option either because it's moreso intended for use as a textbook than for self-learners. I'm not sure how good it would be for the task of self-learning; it probably takes the more is better model so that instructors can pick out what they want.

It's definitely a lot of content but honestly it's interactive models and mid-chapter exercises lend itself very well to self-learning. My teacher assigned it in it's entirety so we're reading it front to back in order in class.

CS 61B seems like a good option at a glance assuming that How to Design Programs is sufficient preparation and it complements CS 161 as well as we need it to.

Yea, honestly why don't we just use CS 61B? It seems to be what we want right? I mentioned I was going through the course but I didn't have the time to progress far so I can't vouch for it, but it seems like it's fully available to the public unlike other the other CS 61 classes.

Going with Princeton's Algorithms course, we could replace Intro CS with Princeton's Computer Science: Programming with a Purpose and Computer Science: Algorithms, Theory, and Machines as a prerequisite.

I still really think we should have the Princeton Algorithms course (Parts 1 & 2) followed by the Roughgarden course as mandatory for a full coverage of algorithms from different angles. They're clearly complementary to each other. And probably CS 61B before it.

Those two courses seem like they'd be very interesting introductions for CS but I'm not sure since I haven't taken them.

kishvanchee commented 4 years ago

For anyone starting out CS/programming, personally I suggest the following sequence of courses - Intro to CS -> Data Structures -> Intro to Systems. I have found HtDP to be a good resource, but it gets tedious when you continue to go through it. I think HtDP would serve well with its successor PAPL.

To follow up with algorithms, I think the stanford course would do quite well after CS61B / Princeton Algorithms course. A firm grounding on data structures would help in getting more out of the Algorithms course.

An excerpt from the Algorithms book by Sedgewick

Context The book is intended to follow our introductory text, An Introduction to Programming in Java: An Interdisciplinary Approach, which is a broad introduction to the field. Together, these two books can support a two- or three-semester introduction to computer science that will give any student the requisite background to successfully address computation in any chosen field of study in science, engineering, or the social sciences.The starting point for much of the material in the book was the Sedgewick series of Al-gorithms books. In spirit, this book is closest to the first and second editions of that book, but this text benefits from decades of experience teaching and learning that material. Sedgewick’s current Algorithms in C/C++/Java, Third Edition is more appropriate as a reference or a text for an advanced course; this book is specifically designed to be a textbook for a one-semester course for first- or second-year college students and as a modern introduction to the basics and a reference for use by working programmers.

Alaharon123 commented 4 years ago

This is covered in Theory of Computation in OSSU already.

That's in Advanced CS where you only need to take a subset of the courses. It does cover the material, but in significantly more depth. For example, in the Princeton sequence, pretty much all that needs to be covered is in weeks 4-6 of Computer Science: Algorithms, Theory, and Machines and Regular Expressions part of week 5 and Intractability part of week 6 of Algorithms, Part II

Yea, honestly why don't we just use CS 61B?

Indeed. When there's a Request for Comment, that will be one of the options presented in the body text.

I still really think we should have the Princeton Algorithms course (Parts 1 & 2) followed by the Roughgarden course as mandatory for a full coverage of algorithms from different angles. They're clearly complementary to each other. And probably CS 61B before it.

Can you elaborate further on why you'd have both 61B and these two other courses? Wouldn't 61B have a lot of overlap with them?

I think HtDP would serve well with its successor PAPL.

Worth noting that FunctionalCS has links to lectures for Brown CS 0190 (besides for the already freely available homeworks and labs), which covers PAPL and only requires a subset of HtDP as preparation.

spamegg1 commented 4 years ago

However, a safe suggestion would be the Princeton Algorithms course (Parts 1 & 2) followed by the Roughgarden course since Princeton's course is highly regarded and states itself that it is complementary with Roughgarden's.

This seems like a pretty good suggestion. So Core Theory would have 2 classes added to it, sounds reasonable. Not too many, not too few.

EDIT: After reading more and thinking more, I noticed that Princeton's Part 1 and 2 courses have a lot of overlap with Core Theory (Stanford). Only Weeks 4-5-6 of Princeton's Part 2 is not covered by Core Theory. All else is covered.

So... no, let's not add those courses.

I also disagree about Stanford's course being too mathematical and not implementational. I implemented every algorithm in Core Theory, and there are programming assignments for all of them, including Challenge Data Sets (with millions of data points in some of them!), IN ADDITION to the mathematical proofs. It's just that Tim Roughgarden gives all the algorithms in pseudo-code form, then leaves the choice of programming language and the implementation up to you.

waciumawanjohi commented 4 years ago

Just to add some context to the conversation: Princeton's algorithms courses used to be the courses recommended by OSSU. Unfortunately, Algorithms II wasn't offered for years at a time, and so OSSU replaced them with the Stanford course. I cannot remember anyone impeaching the quality of the Princeton courses.

waciumawanjohi commented 4 years ago

@Alaharon123 you wrote:

Going with Princeton's Algorithms course, we could replace Intro CS with Princeton's Computer Science: Programming with a Purpose and Computer Science: Algorithms, Theory, and Machines

Do you think this would be a mandatory change (the addition of Alg 1 & 2 wouldn't work without it) or an optional change? Bundling a change to Intro to CS with the change to Algorithms increases the complexity. All else being equal, less complex solutions are preferable.

(Which is not to say that we couldn't do it. I just want to be clear on the options you envision)

Alaharon123 commented 4 years ago

Well you need to learn Java before Princeton Algorithms. You can say hey y'all go learn Java on your own, you should be able to do that by now having taken intro cs and How to Code, but I don't know about that. So then you have two alternatives. Princeton's intro course would work well as a replacement for Intro CS since it's also a survey course and the prerequisite for Princeton Algorithms. Or, after How to Code, you can use WPI's course, which is currently uploading lectures, taking away that downside (although you'd still have to work with others so you have grading, but if we make a discord as is being discussed, that shouldn't be a problem. Or it could be a driver for cohorts). It's worth noting that OpenDSA also requires knowledge of Java beforehand so one of these routes would be required for that too.

Alternatively we just use Berkeley's CS 61B. That's certainly the simplest option. I have not taken a close look to see if it's a good fit ACM-wise or prerequisite-wise.

So I see three different options for the Data Structures course, Berkeley, OpenDSA, and Princeton. If using one of the latter two, I see two ways of dealing with prerequisite, Princeton and WPI. Note that regardless, none of this is replacing Stanford as Princeton did in the past, rather it's augmenting it.

waciumawanjohi commented 4 years ago

Fair enough.

On finding a java course (if one is necessary): There are some sources of knowledge outside of OSSU that we can look to for such an option. reddit's r/learnjava has long valued the University of Helsinki's Java Programming course. I've taken a previous version of the course and found it sufficient. As you've pointed out in a conversation elsewhere, it really does begin with explaining what a variable is. That also seems to be the case for the Princeton's Computer Science: Programming with a Purpose.

You point out that Princeton's course could be a replacement of Intro to CS. Helsinki's course could be a replacement of Programming Languages C, covering the learning expectations of object oriented language behavior. Unlike the Princeton or WPI courses, it spends time exploring inheritance, interfaces, abstract classes, all expectations under CS2013. (I took a glance at Programming Language Part C and from the syllabus, students may be missing this information right now)

Separately, on CS61B, I wanted to see what's been written about the course. I googled reddit and 61b. Ended up reading through a long list of posts from Berkeley students about the "notorious" course. Oddly, posts about the course from students not at Berkeley seemed more uniformly positive.

spamegg1 commented 4 years ago

@waciumawanjohi I hope you don't replace PLC (it covers interfaces, abstract methods and multiple inheritance by the way). I actually really appreciated a non-Java take on OOP in that class. It has an excellent programming assignment, writing the same code in ML and in Ruby, contrasting polar opposite programming paradigms (OOP vs Functional Decomposition). Moreover I'm pretty sure PLC talks about a lot of things some Java courses would not, such as Mixins, Dynamic Dispatch, Double Dispatch, parametric polymorphism. Java was covered by the two Software Construction classes before and they certainly didn't cover any of that.

I think it's best to just add a standalone "Java for the sake of Java" course. Java doesn't own OOP, is not necessarily representative of all OOP, arguably is not even the best option for OOP. Java is just... Java. It has its own peculiar universe.

aryzach commented 4 years ago

I'm also with @spamegg1 and had similar thoughts when I saw the considered replacement. I think PL A, B, and C talk about PL in a way more closely to understanding semantics and evaluation, which is a more academic and interesting conversation. The Java-based Software Construction series that we got rid of talked about inheritance, abstract classes, etc in a different way. Basically just how to make and use good abstraction layers. But Software Construction is more of a 'design' conversation and not PL fundamentals.

Secondly, if the algorithms class is using Java and people take the algorithms sections in the recommended progression (after HtDP, PL, CS50, nand2tetris), they should definitely be able to pick up Java. I also think it's really good practice anyway. In nand2tetris, you use a Java-lite language (Jack), and actually build a compiler for it, so I think you get a pretty good idea of the language. Maybe we could just have 'if you haven't taken PL, CS50, nand2tetris, then take this Java intro course, otherwise, you might have to look a few things up about syntax and classes, which is a good way to learn the language too!'

spamegg1 commented 4 years ago

@aryzach Agreed, I also think people can easily pick up Java when they reach the suggested addition of two Princeton courses to Core Theory. But if it's absolutely necessary, it would be best to just add a short quick Java course after PLA-B-C.

Moreover since the suggested Princeton courses are on algorithms (rather than some big complicated project with UML diagrams etc. like in SoftCons), I think that Java's object/class/inheritance/OOP design stuff will not be much relevant or needed.

Alaharon123 commented 4 years ago

As you've pointed out in a conversation elsewhere, it really does begin with explaining what a variable is. That also seems to be the case for the Princeton's Computer Science: Programming with a Purpose.

Yes. And just like it wouldn't make sense to replace Programming Languages C with Princeton's course, I don't think it would make sense to replace it with Helsinki's course.

Unlike the Princeton or WPI courses, it spends time exploring inheritance, interfaces, abstract classes, all expectations under CS2013. (I took a glance at Programming Language Part C and from the syllabus, students may be missing this information right now)

This is true regarding Princeton's course, not true regarding WPI's course. Hopefully people who have taken Programming Languages Part C can comment on whether or not it covers those topics and therefore how much Princeton's course should be considered.

I looked further into WPI's course and it actually covers everything we need without the addition of Princeton's course. It sounds like you've both taken the Software Construction courses that were previously in the curriculum @spamegg1 and @aryzach. Can you comment on how helpful it was or wasn't to learn Java and design from the perspective of a continuation from HtDP as opposed to learning it from scratch like in CS 61B?

I've also looked a little bit further in CS 61B, although probably not enough, and it does seem like a good fit. I'm not 100% sure that it covers everything, but it looks pretty good from a cursory look aside from possibly AL/Basic Automata, Computability and Complexity. One of the professors who teaches it, Josh Hug, puts video lectures online and allows guest access to the autograder for at least some things. You can access the latest run he's done at https://datastructur.es

if the algorithms class is using Java and people take the algorithms sections in the recommended progression (after HtDP, PL, CS50, nand2tetris)

Would that be the recommended progression? I was imagining it taking the place of the Software Construction course right after How to Code since whichever course we choose is a CS2 course with the only prerequisite being CS1 just like Software Construction was. I don't really know what falls under programming, what falls under theory, etc though.

aryzach commented 4 years ago

Would that be the recommended progression? I was imagining it taking the place of the Software Construction course right after How to Code since whichever course we choose is a CS2 course with the only prerequisite being CS1 just like Software Construction was. I don't really know what falls under programming, what falls under theory, etc though.

Are you talking about the Java course or the Algo course here? I don't think the Java course should be added to Core Programming. I think it should be an optional course before the Core Theory section. To be honest, this looks like an intro course or second course in CS (data structures is generally a freshman course). I don't think it's necessary.

So basic template:

"Core Theory"

"These classes use Java to talk about these topics. So far in the curriculum, Java hasn't been discussed. Java is an OO statically-typed language. If you've take the CS Intro in Python, PL Part C, CS50, and/or nand2tetris, don't take the Java course. It's good practice to learn language syntax and semantics without a formal introduction. At this point, you know about languages, and should be able to google a few things that you don't know about. Additionally, classes on algorithms aren't Software Engineering course, so they don't make heavy use out of all the language features (the algorithms course could be taught in any language and you'd still learn the same things). If you haven't taken at least two of these classes listed, and don't have other programming experience, take this Java class. It covers a lot of similar material to Intro in Python, PL Part C, and CS50, just in a different language."

[Java course]

[Rest of theory courses]

Alaharon123 commented 4 years ago

Are you talking about the Java course or the Algo course here? I don't think the Java course should be added to Core Programming.

I don't either. I'm imagining one of the following two scenarios.

  1. Intro CS is switched to Computer Science: Programming with a Purpose and Computer Science: Algorithms, Theory, and Machines to account for adding Princeton's Algorithms course or OpenDSA
  2. WPI's CS 2102 or Berkeley's CS 61B are added with no additional changes since they already teach Java

All of these courses are intended to have only one prerequisite (either Princeton's intro course linked above or HtDP/SICP). I was referring to OpenDSA, 2102, 61B, and Princeton's Algorithms with which course might be taking the place of Software Construction in Core Programming rather than going in Core Theory. I'm not personally in favor of adding a full course on Java. Please make the case for it if you do think that's better than any of these routes, which integrate it into another course and don't add more than one course to the sequence (or make the case that we should purposely choose Princeton Algorithms or OpenDSA and not switch Intro CS to Princeton's)

aryzach commented 4 years ago

Intro to CS with Princeton (both courses) look good from the syllabus, but I haven't taken them. I especially like that the second one goes into theory (turing machines, etc) which we don't currently have in Core CS (unless it's in Core theory which I haven't taken). If somebody can speak to the quality of these courses, I'd be for it. Also, do we know how long these classes will be supported and free?

That said, would that mean getting rid of HtDP? I personally think those two course are great and haven't seen any other class like it.

Could you layout a template (class listing) of your proposal using the Princeton classes for both intro and algo/theory so I can understand it better?

Also, the OpenDSA looks like it just teaches data structures. Is that true?

So

Intro [Class 1] [Class etc...]

Core Programming [Class 1] [Class 2] [Class 3] [Class etc...]

Core Theory [Class 1] [Class 2] [Class 3] [Class etc...]

spamegg1 commented 4 years ago

It sounds like you've both taken the Software Construction courses that were previously in the curriculum @spamegg1 and @aryzach. Can you comment on how helpful it was or wasn't to learn Java and design from the perspective of a continuation from HtDP as opposed to learning it from scratch like in CS 61B?

Software Construction doesn't teach Java from scratch. It gives you small to mid-sized project codes already written. So you don't have to know too much Java. It begins by asking you to draw UML Class diagrams of the code they give you. Then goes through how to use the debugger in IntelliJ IDEA. It teaches some Java concepts. So the entire course is more like self-study with paper and pencil; there is no auto-grader to submit programs for correctness or anything like that.

For the Final Exam/Project you write just a tiny bit of code into a large project they give you. Throughout the entire course you write almost no code. The little code you write does not solve any problems or implement any algorithms; it is about bureaucracy and bookkeeping: keeping track of class hierarchy and calling the right method of the right class at the right time. (Also they want you to pay to have your final "graded".)

I would say SoftCons is 100% design oriented. Not 99%, but 100%.

I would say it had NOTHING to do with "a continuation from HtDP". In those courses you wrote code from scratch usually. Also that course used Racket which is a functional, Lisp-like language. These two courses are so orthogonal and opposed to each other, I cannot think of anything else like that. I think that's actually what they were going for. To 'cover all bases' in some sense. I found HtDP incredibly useful, and SoftCons to be just a nuisance to go through and get it over with as quickly as possible.

I don't know about CS 61B, but when I learned Java way back in 2002, it was much, much, much different than SoftCons. I remember going through the usual motions: Hello World program, making some Java Applet GUIs (they were all the rage on the web back then), implementing a Poker game by creating Deck and Hand objects/classes etc.

So if the suggested Princeton courses are going to use Java, it will be for problem solving and not for design. I don't think there will be some complicated Java class hierarchy to write a Breadth First Search algorithm or QuickSort, you know? SoftCons would be utterly useless to prepare for those. I am guessing the Princeton classes will use Java's built-in data types like HashMap, Array and such. SoftCons NEVER goes over those.

Alaharon123 commented 4 years ago

@ola-sk I've taken a somewhat closer look at 6.006.

Pros:

Cons:

Alaharon123 commented 4 years ago

@spamegg1 I didn't explain myself well. I was thinking as if Software Construction actually teaches Java, which it doesn't really. Thus, I was asking a bad question. I was asking in order to see how much benefit there might be in using WPI's CS 2102 though), not in bringing back Software Construction. CS 2102 follows from CS 1101, which uses HtDP and How to Code videos. It actually transitions from Racket to Java, showing how the HtDP principles apply in Object Oriented Programming.

spamegg1 commented 4 years ago

@Alaharon123

It actually transitions from Racket to Java, showing how the HtDP principles apply in Object Oriented Programming.

Oooooh, that's actually pretty cool.

I really liked those principles. Data structures determining the "template" for any functions you write, and the orthogonality of data design and function design (separation of concerns, or "aspect oriented programming"). I really wanted those principles to be continued but I never saw them again in future courses.

I think I understand your question now. Since the curriculum already has How to Code, I think I can get behind this course you mentioned. It could come right after the two How to Codes, before PLA-B-C.

Alaharon123 commented 4 years ago

So I PMd @spamegg1 on Gitter since they're almost finished OSSU and gave them a pdf of just the parts of cs2013 that should be covered in Intro CS, How to Code, this potential Data Structures course, and Core Theory/Stanford Algorithms (and Programming Languages since we rely on that for OOP). Turns out if you add CS50 and nand2tetris to the mix, you get close to full coverage already with the missing parts being too scattered to have one course cover. To give the short version before I give their breakdown, Stanford Algorithms covers more than I or OP thought, Programming Languages Part C does indeed have sufficient coverage of Object-Oriented Programming although spamegg1 thinks that we should still be trying to get actual Java coverage into the curriculum, and 6.00.1x, CS50, and nand2tetris along with other courses fill the majority of Software Development Fundamentals. Here's the pdf I gave them if you want to go through it yourself without all the bloat of the full cs2013 document: cs2013-selection.pdf. And here's their breakdown, with cs2013 lecture hours added in brackets, light editing for clarity/consistency, and split up into things in Core CS and things not in Core CS:

Not in Core CS:

The knowledge units not covered are a scattered bunch rather than cohesive so I would conclude that we are not in need of a course to fill the Data Structures/CS2 gap because that gap is already pretty much filled by Intro CS, Core Theory, the first half of CS50, and Nand2Tetris.

I want to note that if CS2013's breakdown of Princeton's intro course (page 448) is to be believed then switching to that would provide 2 more hours of coverage of AL/Basic Automata Computability and Complexity, Core Tier 1 (finite state machines and regular expressions), the 1 hour of coverage of CN/Intro to Modeling and Simulation, some coverage of SDF/Algorithms and Design: Fundamental design concepts and principles, and 3 hours of coverage of SDF/Development Methods. I am not necessarily advocating for it because I don't know that it's the best fit for OSSU because of the reasons stated by @kishvanchee at https://github.com/ossu/computer-science/issues/664#issuecomment-609030242, but it could be worth considering, especially if we ever go wildcard on Intro CS. Basically I'm putting this here so if anyone ever does want to make a case for it, they can hopefully find this and use it in their case.

And maybe there's a case for moving Software Debugging and Software Testing to Core Programming? I don't know. The actual gap would seem to be Development Methods and Algorithms and Design: Fundamental design concepts and principles so maybe.

EDIT: CS 2102 would seem to be a pretty good fit for that, but I looked at what WPI students have to say and they don't like the lectures. Also, as @yeminzaw04 pointed out on Gitter, it doesn't have solutions to quizzes, labs and homework so that seems to be a no go. The HtDP approach seems to be to follow HtDP with a course teaching Java and extending the principles and teaching more about design rather than going straight to algorithms like most schools, but WPI's and UBC's courses are not great for self-learners, and Northeastern doesn't have it's course available at all. I don't remember what other schools use HtDP, but iirc from checking last time, none of them have their follow-up set up well for self-learners either.

We (me and spamegg1) encourage you to go through cs2013-selection.pdf and post your own breakdown of what's covered where and see where you may disagree.

ahmadelzohairy commented 4 years ago

Hey, since I remember some considerations about creating along the curriculum which has not necessarily free-only courses included, I'd be interested in opinions about how something like https://www.edx.org/micromasters/ucsandiegox-algorithms-and-data-structures goes along the rest of the curriculum if one aims at more data science related knowledge of algorithms. I've copied "what you'll learn" and "syllabus" sections from all of the courses in the micromasters for a quick comparison here. Thank you in advance.

is this the same as coursera https://www.coursera.org/specializations/data-structures-algorithms

krishnakumarg1984 commented 4 years ago

I have now read the whole thread. There wasn't a continued discussion or interest expressed for the UCSD data structures course (part of the micromasters program). In my (amateur) viewpoint, this course seems like a good one. Can the experts here look at this more closely?

Secondly, why is Steven Skiena's book and/or video lectures not being considered? This is the recommended material for teachyourselfcs.com, but it is not even in the radar of ossu. Why is that?

krishnakumarg1984 commented 4 years ago

6.006

I have sampled three courses on Algorithms so far

  1. Roughgarden's course on Coursera
  2. Sedgewick course on EdX, and
  3. MIT 6.006 on OCW.

Among all three, I think MIT 6.006 should be the recommended curriculum here at OSSU. It seems to strike the right balance between hard theory & proof-oriented material and just implementing code.

6.006 piques the student's interest with easy to understand problems. Also, personally I find MITT 6.006 professor's narrative/style easier to follow and more engaging than either Stanford's or Princeton's courses.

Can the moderators look into MIT 6.006 for algorithms?

Alaharon123 commented 4 years ago

@krishnakumarg1984, these are good resources for algorithms. Thanks for bringing them to light.

Skiena's course would appear at first glance to be a follow-up course to something like the Stanford course we currently use and only has assignments available in the nonfree textbook and is in general not really set up for free self-learning. I wouldn't expect it to be a good fit for OSSU, but perhaps a more thorough review would show how it would fit well.

The UCSD and MIT courses look plausible. I can imagine a future RFC that successfully argues for their inclusion.

Alaharon123 commented 4 years ago

I would like to offer my conclusion from the exploration of this topic over the Spring: the Stanford course is adequate and a better choice for OSSU than the Princeton course although there are knowledge areas that are not completely covered. As a result, I'm not gonna make an RFC myself. There's room to though if someone else is willing to do the work showing that whatever course is a better fit for OSSU than the Stanford course we currently use. I expect this thread will be useful in any such endeavor.

waciumawanjohi commented 4 years ago

I'm glad that so many students were able to dig in and explore this question.

Students who are interested in comparing new course suggestions are welcome to find like-minded contributors in the computer science channel of our Discord. Reach out to a moderator of Discord if you'd like a dedicated channel for that discussion and exploration. And if/when there is a proposal for changing the curriculum (which would include a comparison against our curricular standards), please open a new Issue with a Request for Comments!

krishnakumarg1984 commented 4 years ago

@Alaharon123 Will a future RFC refer to this closed issue? What are the outcomes of the detailed discussion that took place here.

It shall be helpful if the moderators can provide closing comments summarising the discussions & the decisions taken.

riceeatingmachine commented 3 years ago

Here is another interesting specialization on data structures and algorithms: https://www.coursera.org/specializations/data-structures-algorithms#courses

The instructors are very good, I did their intro to discrete math course.