Introduction to Computer Science and Programming Using Python

As a beginner to python, this course pushes me to the limit.

Criticism first, as pointed out by different people, the professor made too many careless mistakes in explaining a concept, he also did some scribbles that somehow confused me even more (in a point of view of a python beginner). Lots of terms (like some relating how does the computer works) were also introduced but left unused throughout the whole series. Also, the final and midterm are not available for people who are auditing the course, wish I have had more exercises so that I can get more out of this course ☹

However, some critics claimed that the grader’s testing is too strict, I think this is not true. As long as you carefully read the instructions, the grader accepts your input. The grader can help my coding become more precise in my opinion because it shows you which test case that the answer is incorrect, and you can debug your code accordingly.
Bad comments aside, I think this is an excellent course for beginners in computer science! For a complete newbie like me, I felt like I had learnt a lot during these 2 months. It provides me with a very broad yet introductory insight into object-oriented programming. However, it does not mean that this is an easy course. The assignment is super challenging, often I spent 3-4 days working on the last question of each problem set. It requires me to check carefully any arguments missing, how to handle borderline cases, and to translate what I think in my head to short and concise codes.

One thing worth mentioning is Spyder, the integrated developing environment (IDE) used by this course. Learning to code in Spyder is one of the best coding experiences I have had so far, this is because it will automatically indent, fill in colons and hint you when there are some obvious errors in your code. Some may argue that it lets you become less vigilant on debugging, but as a beginner, I think it does more help than harm.

Overall, although this is a challenging course, I had a rewarding experience when learning, highly recommend to people who wants to start learning python like me!

This is an excellent course that will teach you some Python, but more importantly will teach you algorithmic thinking and how to break down large problems into simpler ones. I came into it with some self-taught Python knowledge and found it challenging but manageable. Absolute beginners may want to first try Google's free Python course or some other quick introduction to the language.

The problem sets are very hard, but also the best part of the experience: they drive home the lecture concepts and completing them successfully makes you feel accomplished. Some examples: we had to write programs that could monitor news feeds over the internet, simulate the behavior of a Roomba vacuum, model the growth of viruses in a sick patient, and determine the best path between nodes on a graph. You always have two weeks to complete a problem set, which is enough to give you some flexibility yet still allows you to stay on a steady schedule.

There were some logistical difficulties with the course: the last problem set wasn't released on schedule, and so the concepts I learned towards the very end of the class felt a little rushed and untested. But I imagine that these wrinkles will be smoothed out in the future.

In short: it's a challenging class for CS beginners, but definitely recommended.

I'm taking this class as a refresher and as a way to dig into some sorting algorithms that I haven't used in awhile but if I was new to coding/python, I would find this class to be very confusing. The lectures aren't presented very clearly. The slides are disorganized, often times with the professor making random, nonsensical scribbles that are more distracting than helpful. When you do see the code example screen, there's old code, unused code, and sometimes superfluous code that would be extremely confusing to a beginner. Topics in the first few weeks don't seem to build on one another in a very logical manner. The exercises seem to be very pedantic in nature. The tests that run against your solutions to the exercises require the solution to be entered in an exact format. So for example, if you enter in "1,2,3,4" your solution will be rejected since the tests is looking for "1, 2, 3, 4". There's a bit of irony in that a class on programming doesn't have a test capable of parsing out the solution you input. Maybe I'm not paying as much attention as I should, but I swear there are exercises that ask you to use concepts you wouldn't know about from just having watched the lectures. In addition to these issues, there are some community TA's that seem to be almost combative in the class discussion forums. I'm really hoping that this class improves the deeper in you get. I'd imagine that a lot of people take this class purely based on the prestige associated with the MIT name but if you're new to coding you'd do yourself a favor by either taking Harvard's CS50 or grabbing the topics in the course and finding one of the hundreds of bootcamp blog posts that cover these same topics.

I just finished this class. It was much harder and moved much quicker than any other MOOC I have taken. I learned a lot, but it was a lot more work than I had really anticipated. I am a complete novice with no programming experience, so perhaps that was my fault.

I did finish (just this second) and did get a good grade, but I put far more time and effort into the class than I had expected. Be prepared!

As an example the first 3 'week' projects are due 4 days apart (Thurs, Tue, Fri due dates) so the 'week' concept was a bit misleading. Again, I really enjoyed and learned a ton, but I hope others know their expectations.

Also a lot of the work is self taught. You need to go out and find the answer far more than expect the answer to be in the videos or exercises.

This is a well-crafted, fast-paced introduction to Computer Science, though a little dry at times. I think it's based on the introductory 'CS for non CS majors' course at MIT.

The pace, relative complexity of some of the subject matter* and difficulty of a few of the exercises - I'm not a gifted programmer and I found a couple fairly challenging despite some background - might make it better suited as a second (or third) course for some, despite using Python (perhaps the easiest programming language to pick up). Rice's IIP or Udacity's CS101 - which I'd both done earlier - would both be good preparation (or fallback options, if you try this and find it too hard).

I just completed the final exam, which is untimed (you get a long weekend to complete it) & accounts for 25% of the grade). I seemed to test a pretty representative selection of the material, at a level comparable in difficulty to the homeworks.

*It includes introductory material on object orientation (including inheritance), recursion, data structures (trees) and algorithms (including big O notation, tree search).

The course moves very quickly and has required 20+ additional hours of work weekly beyond the instruction. The lectures are very contained in their scope, but the scope of the problems jumps far beyond the lecture and requires much unsupported research (really guessing, in many cases!). This problem could be easily rectified with a more gradual evolution of problems. (Bridging problems between the current short end-of-lesson questions and complex weekly problems.) On-screen the graphics are difficult to follow with a very small font making it hard to see key characters. The execution screen is full of past work and so that with the phrase "Let's see what this does!" it is unclear (and obscured) what was typed in and what resulted since you visually have to jump from the code screen to the execution screen in the midst of lines of text (and again, a very small font). And while this may not be the typical "requirement" of a college course, the examples of where and in what context a given code might be utilized is much better provided in other online courses. The course content on the whole is solid but half-baked in execution with poor visuals, pacing, and contextual application to the real world.

A life-changing MOOC. I take this MOOC aside from my work as a government clerk in China in 2016, which is very unsatisfactory. At that time, I was 24, graduated from an Econ & Business university, beaten by the humiliating experience of working in a rigorous hierarchy, and most relevant, never touched programming.

This MOOC helped me to recognize my potential in the field of computer science. It is demanding, even might cause you scratchingly uncomfortable. But it is definitely a worth try. As the saying goes, "good things take time".

I finished the course a bit more than 2 years ago, and guess what? From a speck of humble dust in the giant bureaucratic machine, to a first-year Bachelor student of Computer Science at a recognizable university at the age of 26!

My life trajectory is running on a new track, and in the determination of this amazing transition (it is especially hard if you are from the developing world where the society is not so tolerant), I'd say this MOOC plays a fundamental role.

Thanks to edx, thanks to MITx!

Great course! But you have to work a lot, not get frustrated and be ready to think out of the box and get out of the comfort zone to solve the problems.
One of the things to take away from this course for me was that coding of complex programs is not done alone. Brainstorm with some one else if the approach you are taking to solve the problem is on the right track. Pseudocodes are important.
Another thing I learnt in this course is that they make you work hard on the Problem sets so that you are well prepared for the Finals. You may have difficulty winning the battle but you will win the war because you are well prepared for it.
At the end of it, it's real power when you tell the computer what you want it to do and it does that!

This was probably the best introduction to computer programming I have ever seen. The professors are engaging and the lectures are short and to the point. Finger exercises between lectures really drive home the points that the professors were trying to make. The programming assignments were challenging enough to make you feel like you have accomplished something, but the specifications were generally enough to get you through it. The forums were invaluable to completing the assignments and were full of very bright students with excellent questions. The Midterms were very challenging, especially the first one. I liked how once the fundamentals of Python were covered, the focus moved to solving real world engineering problems, but I still feel that there is a lot more to learn about Python. I'd take another class from this MIT group in an instant.