Introductory Courses

[yusuf340809]

I have been trying to learn code for last 2 years but my attemps were more towards game programming in Unity and I didn't try to have a solid background in computer science. I was able to make my own game but as I had performance problems, I decided to get a computer science foundation before I move to game development. Here I am.

I have taken CS50. The teacher is great. Course is a good starting point. But in my opinion, it is a good start if you are at Harvard campus where you have office hours, sections, labs etc. Each lecture touchs a very big topics superficially. And those who are at campus can digest the content with the help of CS50 staff. We don't have that.

First few lectures were not that hard for me and I was able to solve problem sets. But as it started to get more advanced with topics like memory and data structures, I was just watching the lecture and practicing what I saw at lecture. I had a hard time with problem sets. This is not because problem sets are supposed to be hard. The content that I have to learn to understand the problem sets and answer them was not fully digested as the lecture was broad and not every concept fully explained in detail. Also keep in mind that I had some exposure to programming before.

Here is what I suggest and this is the path I am following now. There needs to be some beginner friendly course that helps you understand the basics before you move on with CS50.

(https://www.edx.org/course/introduction-computing-using-python-gtx-cs1301x) This is the course I am currently taking and it is a great content, beginner friendly course in which you can contact the instructor directly and ask questions on slack.

[joshmhanson]

It's not clear to me why you dislike CS50 as the first course. CS50 is a survey course; it's not supposed to go into much detail in the lectures, but merely touch on many different topics. Note that there are supplemental videos created by the course staff that are more detailed than the lecture on each particular topic, and there are also walkthroughs on how to complete each problem set. These videos are typically embedded in the pages for the problem sets. Did you find these videos helpful?

Also, How to Code: Simple Data, the first course in Core Programming, is very similar to the course you linked, in that it is very beginner friendly and you can directly ask questions to course staff. It's easier than CS50 partly because the scope is much smaller, and partly because it uses a teaching language.

There are really three possible starting points in the curriculum. You'll notice they all list "None" under prerequisites:

• CS50
• How to Code: Simple Data
• Nand2Tetris I

The reason we recommend CS50 first is because it's a survey course. (Plus, Nand2Tetris's hardware specifications use some pseudo-code that looks like C, so it's useful, though not strictly necessary, to start with C.) Yes, CS50 is harder than the other two, but if you find something too hard, just try one of the others. The beauty of our curriculum is that, unlike in a physical university with rigid rules and schedules, you can start, stop, restart, and change gears however much you want in order to find what works for you.

[pachecohjr]

Would anyone be able to tell me what the difference between CS50 and CS50 AP: Computer Science Principles are? I'm just curious since I've always wanted to see all the videos CS50 had to offer since I liked how they introduced C in their coursework, like one university I attended. I see other schools around me introduce using either Python, Java, or C++.

• HarvardX CS50: AP Computer Science Principles

[arcanemutterings]

@pachecohjr https://www.reddit.com/r/cs50/comments/5ky73h/cs50_vs_cs50_ap/

[amorriscode]

@yusuf340809 As someone who is about to start How To Code: Simple Data, is working as a developer, and has progressed from CS50, I have to disagree. I agree with what has been said before; CS50 is an intro. It's supposed to give you a taste of what you could experience if you continue down the path of computer science. I don't see why you expect it to be easy? I think all courses should get progressively more difficult, and that's a good sign that you are doing something valuable.

If you wanted, you could start (or join) an OSSU cohort for CS50 and get some help from the people there! Also, CS50 has some decent groups online that I was apart of, I even talked to David directly a few times.

[yusuf340809]

@hanjiexi It is not about me liking or disiliking CS50 as the first course. My point is that CS50 is not a beginner friendly course. It is a survey course the lectures are well designed. But apart from the lectures and shorts you need some help or teaching in order to deal with problem sets. At least for me, the course did not provide enough to solve the problem sets. This is my case, your may not be the same. But as there might be some others like me, I thought that a more beginner friendly course can be a good fit before CS50. I do not agree with you that taking CS50 and Nand2Tetris are two optinal ways. Because both courses are very different and the students will learn different things. I am currently doing what you are telling. In order to prepare for MIT 6.001, I am taking introductory Python course I have talked about.

@amorriscode You are a "developer" and this might be the reason for you to succeed. I am a beginner and I had a hard time with CS50 as it was the first course. CS50 is an intro course (touch on very little) but the topics are advanced and the problem sets. But I do agree with you that I have to get into cohort or groups more.

[amorriscode]

@yusuf340809 Sorry, I guess I misunderstood you because your description makes it seem like you have some programming experience. For a complete beginner, I have no doubt that these courses could be challenging, but I also don't think that it's a bad thing.

[joshmhanson]

@yusuf340809 Thank you for your feedback. I really do value getting diverse opinions about the course progression, as many of the people involved in creating the curriculum (including myself) already had some familiarity with computer programming before starting OSSU CS, which might create bias against people who have truly never been exposed to it, or were exposed to it in a way that didn't help them.

I do not agree with you that taking CS50 and Nand2Tetris are two optinal ways. Because both courses are very different and the students will learn different things.

They are indeed very different, and both are required as well for this reason. What I'm saying is that the fundamental concepts of computer science are ubiquitous to every course. For example, you end up learning and practicing a lot of basic logic in Nand2Tetris, and you also learn about abstractions in a very practical way. Logic and abstraction are used everywhere in computer science. So someone could hypothetically start with Nand2Tetris and develop a strong grounding in these two fundamentals, and then find it easier to solve some problem sets in CS50 because they require you to think logically. CS50 can be very overwhelming for someone who has to learn programming, logic, abstraction, low-level hardware details, etc., all at once.

On the other hand, as I mentioned before, knowing C (or something very similar) is a very useful background to doing Nand2Tetris because of how they write their hardware specifications. It could be very overwhelming to try Nand2Tetris without having any familiarity whatsoever with computer programming.

So on some level you are right and I agree with you. The other side of this is that we want OSSU CS to be rigorous and challenging, but doable. Learning is most efficient when what is being learned lies just beyond the student's immediate abilities. Finding this balance in a way that works for everyone is tricky for a regular university, and much more so for an audience as diverse as OSSU's. It's something we should continue to ponder.

[stephen-lothrop]

First off wanted to say thanks to everyone who has contributed to this curriculum. It's been great to have direction in my studies and feel like I have a defined path to the knowledge I want.

This may belong in a new thread, but because this thread hasn't been closed I thought I'd post on this one. I've made it through cs50, MIT 6.001, HtC: Simple Data, Htc: Complex, and Software Construction: Data Abstraction. Before starting the OSSU curriculum I had taken a course in MATLAB, but that was about it as far as my knowledge of computer science.

I agree with @yusuf340809 that cs50 is a really challenging course and maybe more challenging than it should be for the first course on the OSSU curriculum. MIT 6.001 seemed significantly more doable and provided a great introduction as far as I could see. I agree that cs50 provides a value in teaching you about pointers and memory. Recursion made no sense to me until I got through the HtC courses. Does Nand to Tetris touch on the low level concepts that cs50 does? I think HtC or MIT 6.001 would be a better first course in the curriculum.

After going through the courses that I have I did feel like there were too many introductory courses. Cs50, MIT 6.001, and HtC all teach important topics, but after taking four courses I still haven't dived very deep. I think we should narrow down the introductory courses so that people will be able to move deeper into the curriculum faster. If no other course talks about pointers and memory in the way that cs50 does, then keep it on but don't make it the first course. Either MIT 6.001 or HtC should be the first course. Both are much more approachable than cs50 for someone who hasn't had any programming course or didn't get good enough grades to get into Harvard. Next cs50 could be done, and then move on.

[amadeann]

@stephen-lothrop Nand to Tetris goes even lower level than CS50 :) I think it's as low-level in computer science as you can get.

[Abhi18022]

I think CS50 is actually a right place to start with yeah i can understand that they covers some of the advance topics like memory and data structure but i don't think that CS50 is for teaching you any of these. CS50 is a introduction to Computer science where you comes to know about all the different kinds of things you are going to learn in deapth in future in CSE. I took CS50 as a motivational Course for Computer science where you get's the analogy of CS.

have you heard of "ADEPT Method" of learning ? well NO! then must have a look at it. https://betterexplained.com/articles/adept-method/ By the ways i will not prefer go for problem set's after CS50. CS50 is just a knowledge based course or you say it's a "documentry on Computer science".

this is way i like to think about CS50 :)

[stephen-lothrop]

CS50 still seems to be a difficult course to start out for people who don't have much experience with computers with although I do agree that it covers a lot of topics. Does MIT 6.001 provide additional value that the combination of CS50 and How to Code miss?

[ghost]

@yusuf340809 try scrimba.com it's free i wish more of UI like this so i don't need 2 screens

[waciumawanjohi]

Currently the curriculum says that students should learn CS50 because “they teach C. We wish to retain this in the curriculum for now because it is one of the few chances the student has to play with manual memory management in a (relatively) low-level language.”

I submit that manual memory management is not a core goal for OSSU. Certainly, upon program completion students should understand how memory management functions, the tradeoffs between a language that does automatic garbage collection vs a language that does not, and the process of allocating memory in a low level language. But none of these ideas is as important to the general computer scientist as data structures or the abstraction of objects.

In addition, we should look to general practice. In 2013, the Association for Computing Machinery’s Curriculum Guidelines for Undergraduate Programs in Computer Science noted that university intro courses are following a “growing trend toward 'safer' or more managed languages (for example, moving from C to Java) as well as the use of more dynamic languages, such as Python or JavaScript.” They are correct. Of the top 25 CS schools in the US, the language of their intro course is: 56% Java 32% Python 16% C/C++ (Berkley, tied for 1st place in US News Ranking, teaches its intro course in Snap! a variant of Scratch.)

To address some of the points in this thread:

CS50 is hard for people that don’t have a background in programming. Our prerequisites mention no exposure to programming whatsoever. So we should ensure that our intro course is approachable for such students. Multiple students are giving feedback that CS50 is not.

All courses should get progressively more difficult. Students do not feel this is the case. They are reporting MIT 6.001x is more approachable than CS50.

CS50 is a good survey course. While the course does touch on a number of different areas of computing, we currently recommend that students do not complete the survey of other topics. Instead, the curriculum recommends moving to MIT 6.001x after learning memory management. The course is not acting as a survey.

CS50 is the harder of the two intro courses, but if students find something in it too hard, they can just try the other. This advice, if something is too difficult, just move on to the next course, is nowhere on the actual curriculum. Nor should it be. Students should trust that the material they are asked to learn is important and will be built upon in later courses. Students should be encouraged to “stick with it”, not to give up on the first course. It is up to the curriculum designers to properly calibrate the intro course.

CS50 is a good introduction to Nand2Tetris. Nand2Tetris is currently the 16th course in the curriculum. CS50 can be placed much later in the curriculum and still prepare students for their deep dive into computer architecture.

CS50 is a good “documentary on Computer science". OSSU biases course selection towards courses that provide feedback to student assignments. If we don’t intend students to complete the problem sets in a class we should: 1) Say that explicitly. 2) Consider moving the material to Extras.

I should note that in Gitter, multiple participants advise new students to save CS50 for later and begin with 6.001x. Why are we saving this advice only for students that search out the Gitter and ask questions before beginning? The curriculum should represent our best advice.

CS50 should not be the first course.

[generationtech]

From my perspective, way too many people get into programming and try to use the easy languages right away that do all kinds of housekeeping for them. These "programmers" eventually end up making really inefficient solutions because they never learned efficiency or careful programming. C teaches that above all else. If you make a mistake in C, it hurts.

And if "it's too hard" for them, good. Because we don't need more bad programmers using languages with training wheels that make for terrible solutions because they can get away with all kinds of sloppiness.

I would take exception with those stats

56% Java 32% Python 16% C/C++

From what I see at my customer sites and from local fellow engineers and technologists, Java is a dead language. I know it's installed everywhere and blah, but it's slogan eventually became "write once, run nowhere" because of the fractured patch level incompatibility of JRE. Every one of us that has any widespread exposure to Java knows of a company with some kind of super critical application written in Java that requires "that specific version" of JRE to run and they are constantly working around that dependency. IT support departments hate Java for the same reason.

But as with anything with training wheels, Java is easy to teach because the language lets you do all kinds of bad things and inefficient algorithms while the JRE goes around cleaning up after you. So a lot of the current teaching programs use Java as the focal point. Why? Because it's easy to teach. I myself teach professionally part-time and have removed Java from the curriculum for several years. We use C for low-level simple hardware-to-program learning steps and then move on to Javascript (and Python :) ) for higher-level algorithms.

I know it's flame bait, but no company anywhere without an inescapable existing installation dependency based on Java conceives any new project using Java, so IMNSHO your use of a Java metric against C is not valid for the larger set of new programmers. The current C war is whether Go or Rust will displace it. I'm in the Go camp.

Not trying to offend your very thorough and thoughtful post above

[waciumawanjohi]

And if "it's too hard" for them, good. Because we don't need more bad programmers using languages with training wheels

1. I participate in OSSU because I'm passionate about expanding education and opening new avenues for people to learn important topics. I don't understand where the idea, "if 'it's too hard' for them, good" belongs in a school. Are we trying to scare people off and make them think they can't learn CS? We should make learning no harder than it need be.

2. We use training wheels when we are beginning to learn something. It's the one time training wheels are good. I said explicitly that memory management should be in the curriculum. But it need not be at the beginning.

I would take exception with those stats

What do you mean? That's what taught first in the top 25 programs in the US. (Follow the link and check for yourself). Presumably the professors at Stanford aren't teaching Java because they're afraid of hard work.

Meanwhile, I'm not proposing a first course in Java. 6.001x is in Python.

I'd love to talk more about the tradeoffs of Java/Rust/Go. Great convo topic and I've got thoughts. But that conversation is different from the discussion of the Introductory Courses. Can we talk more about that in the Gitter?

[KathrynN]

I agree that the course should be moved further down. I've recommended ossu/computer-science to several friends, but always with the caveat that the first course is really hard and I'll help them.

Without that help I'm not sure it's very easy to finish. Remember that the non-cs students taking it at Harvard/Yale have time with each other, the mentors etc. And dedicated study time each week

On Thu, Jun 14, 2018, 04:40 waciumawanjohi notifications@github.com wrote:

Currently the curriculum says that students should learn CS50 because “they teach C. We wish to retain this in the curriculum for now because it is one of the few chances the student has to play with manual memory management in a (relatively) low-level language.”

I submit that manual memory management is not a core goal for OSSU. Certainly, upon program completion students should understand how memory management functions, the tradeoffs between a language that does automatic garbage collection vs a language that does not, and the process of allocating memory in a low level language. But none of these ideas is as important to the general computer scientist as data structures or the abstraction of objects.

In addition, we should look to general practice. In 2013, the Association for Computing Machinery’s Curriculum Guidelines for Undergraduate Programs in Computer Science https://www.acm.org/binaries/content/assets/education/cs2013_web_final.pdf noted that university intro courses are following a “growing trend toward 'safer' or more managed languages (for example, moving from C to Java) as well as the use of more dynamic languages, such as Python or JavaScript.” They are correct. Of the top 25 CS schools https://www.usnews.com/best-graduate-schools/top-science-schools/computer-science-rankings in the US, the language of their intro course https://docs.google.com/spreadsheets/d/1ny1CSCmYkDhCcdpnsJQhcJpaXNXiv1J5z18CdmWRpvs/edit#gid=0 is: 56% Java 32% Python 16% C/C++ (Berkley, tied for 1st place in US News Ranking, teaches its intro course in Snap! a variant of Scratch.)

To address some of the points in this thread:

CS50 is hard for people that don’t have a background in programming. Our prerequisites mention no exposure to programming whatsoever. So we should ensure that our intro course is approachable for such students. Multiple students are giving feedback that CS50 is not.

All courses should get progressively more difficult. Students do not feel this is the case. They are reporting MIT 6.001x is more approachable than CS50.

CS50 is a good survey course. While the course does touch on a number of different areas of computing, we currently recommend that students do not complete the survey of other topics. Instead, the curriculum recommends moving to MIT 6.001x after learning memory management. The course is not acting as a survey.

CS50 is the harder of the two intro courses, but if students find something in it too hard, they can just try the other. This advice, if something is too difficult, just move on to the next course, is nowhere on the actual curriculum. Nor should it be. Students should trust that the material they are asked to learn is important and will be built upon in later courses. Students should be encouraged to “stick with it”, not to give up on the first course. It is up to the curriculum designers to properly calibrate the intro course.

CS50 is a good introduction to Nand2Tetris. Nand2Tetris is currently the 16th course in the curriculum. CS50 can be placed much later in the curriculum and still prepare students for their deep dive into computer architecture.

CS50 is a good “documentary on Computer science". OSSU biases course selection towards courses that provide feedback to student assignments. If we don’t intend students to complete the problem sets in a class we should:

1. Say that explicitly.
2. Consider moving the material to Extras.

I should note that in Gitter, multiple participants advise new students to save CS50 for later and begin with 6.001x. Why are we saving this advice only for students that search out the Gitter and ask questions before beginning? The curriculum should represent our best advice.

CS50 should not be the first course.

— You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub https://github.com/ossu/computer-science/issues/440#issuecomment-397150554, or mute the thread https://github.com/notifications/unsubscribe-auth/AFV6C-vHsqjN0u-0vKoEzDgoJROgTrKJks5t8c0OgaJpZM4Q5CrA .

[joshmhanson]

My opinion of CS50 has shifted over the past year or so. I still like it a lot for what it is, but there a lot of other factors to take into consideration, including those raised by @waciumawanjohi.

Manual memory management

There is no doubt that the concept needs to be in the curriculum. Programs run on computers, and computers do not have an infinite amount of random-access memory. Computation science, therefore, despite being a sub-domain of mathematics, needs to address how to perform computations given only finite resources.

But the world is moving on from C. Ad hoc manual memory management, as taught in CS50, is now of extremely limited use. Rust and modern C++ both use some combination of smart pointers, RAII, and borrow checking. In other words, they have an organizing theory of how to manage memory. CS50 doesn't teach any of this theory, and instead asks students to do it the old-fashioned way, as if asking math students to use an abacus instead of a calculator.

Rust and C++ themselves are of limited use; the vast majority of software being written doesn't have such extreme resource requirements that automatic memory management isn't an option. Some high-quality garbage collectors, like that of OCaml's, if used carefully can perform faster than reference counting or even ad hoc manual memory management. Of course, if there were some hypothetical language that could be written in exactly the same way as garbage-collected languages but had the same performance characteristics as Rust/C++, such a language would be preferable, but it does not exist as far as I know. Based on some light reading I did of the Rust Programming Book, it seems to me (intuitively) that such a language may not be theoretically possible. (But only a PhD specializing in this area would be able to confirm such an intuition.)

My belief is that future versions of the OSSU curriculum should use a garbage-collected language for almost all of its courses, with perhaps one course that surveys that it would be like to live without one, and perhaps one more course that specifically teaches advanced techniques of garbage collection.

Challenge progression

I think what's happened with CS50 is that it was taken by some people who had prior experience (including myself), they loved it since it was suited to their experience level and provided a kind of quaint (if not terribly relevant) challenge, and now they're trying to push it as being the universal introductory CS course for everyone. Some of those aforementioned people might perhaps not have had any experience, but for whatever reason their brains were well suited to the task, through prior exposure to logic or a strong math background.

The evidence shows that this warm feedback is not universal. I wouldn't be surprised if some upper-level courses reached a level of difficulty that some people feel like giving up, but if it's happening in the introductory course, that would suggest it's a problem with the course (and its placement in the curriculum) and not with the student.

Introductory language

I don't particularly care what particular language is used in the first course; any language supporting functions can be used to construct a rich mental model of how computer science works. (The lambda calculus, for instance, is the theoretical basis for all programming languages, and it only supports functions.)

What matters more is how much of it is exposed to the student. I think "hello world" in Java and C already exposes too much in the required boilerplate, leading to a lot of questions irrelevant to what's being taught. But almost any other modern language can just print "Hello world".

Conclusion

I am actually in favor of dropping CS50 entirely at some point, but doing so requires a careful analysis of how to replace anything that gets lost. If we can't drop it, then we need to figure out where best to put it.