- 10 reviews
- 8 completed
This is a course with a lot of potential, which unfortunately it completely fails to live up to. Video lecture quality is mediocre at best. The instructor lectures in front of a large screen, and frequently will be standing in front of the notes on the screen. The lectures themselves are very dry, abstract, and "mathy", which is to be expected for the subject, so I'm not counting this against the class. The homework load is heavy, which would be okay if the instructions were always clear and unambiguous, which they are not. For example, a two-part homework problem would require that you assign values to two python variables, but the variables would not be named in the instructions, so you had to guess which variable should hold which answer. The autograder has a number of problems. Feedback from the autograder was generally unhelpful. For example, there was a four-part problem where the autograder would only respond "Incorrect", without telling you which parts of the problem were wrong. In another case, the autograder would accept an answer of the form "a + b", but not of the equivalent form "b + a". Ambiguities in the homework and problems with the autograder are the sort of thing I expect might get ironed out if the class is offered again. Course staff does not seem to be actively monitoring the forums, and a blanket prohibition on posting code to the forums makes it very difficult for students to help each other. But the absolutely unforgivable sin, the one which prompts the low rating I have given, is that the instructor will not be posting sample solutions to the assignments after the deadlines have passed. If you can't figure out a problem on your own, you are completely out of luck. The way you learn to write better code is by looking at other peoples code, and this class does not allow you to do this at all.
This is not a class about three programming languages - ML, Racket, and Ruby - but a class about programming languages in general, using those three languages to illustrate the design decisions and trade-offs that the creators of programming language make - such as whether to use static or dynamic typing, and whether to support a functional or an object-oriented style of programming. Along the way, you'll get a whirlwind tour of three programming languages, each of exemplify a different combination of programming language attributes: ML is statically typed and functional, Racket is dynamically typed and functional, and Ruby is dynamically typed and object-oriented. The programming assignments are very challenging. You'll implement a simple but Turing-complete programming language "MUPL", which includes first-class functions and closures, in Racket; you'll add functionality to a Tetris game in Ruby; and you'll port a domain-specific language for geometric points, lines, and line segments from ML to Ruby. This class is an excellent complement to Martin Odersky's "Functional Programming in Scala", because it covers a lot of the same concepts, such tail recursion, streams, type inference, and pattern matching on constructors. I took the Scala class before taking this one, but I think they would be just as complementary in the other order. One possible complaint about this class is that you are not provided with unit-testing code for the programming assignments, except for the final one, so it's up to you to write unit tests, which can be time-consuming and a bit tedious. On the other hand, writing unit tests is a skill that a professional programmer needs to develop, and this class gives you plenty of practice.
The biggest problem with this class, I think, is that it's language-agnostic. At first I thought that would be great - I can use whatever language I'm most comfortable with - but there are big downsides to this. First, you won't get to see sample code from the instructor after an assignment to compare with your own. And second, since so many different languages are in use, it's hard to get help in the forums. I made it through the sorting algorithms, but I had to give up when we got to graph algorithms, because I had trouble implementing the data structures. I think a better approach would have been to pick a popular language such as Java or Python, and conduct the class in that language. The instructor could then provide a code base that included the data structures, and the students could just focus on implementing the algorithms.
I thought that getting 97% in Ohio State's "Calculus One" MOOC would mean I was well-prepared for this class. I was wrong. The lecture videos are beautiful, and watching the first two weeks, I thought I understood them, but the concepts turned out to be too difficult for me to apply on the homework and the first quiz. I don't know if I've reached my limit of mathematical understanding, or if this class just did not suit my learning style.
I wish I could give this class six stars! Prof. Fowler is the most enthusiastic lecturer I've ever seen - online or in real life - and his enthusiasm is infectious. The lectures are never dry, dull, or boring. The quality of the video is excellent - obviously a lot of work went into getting each lecture just right. In a subject like calculus, it's easy to get bogged down in the algebra and trigonometry. You might set up a problem correctly, then differentiate or anti-differentiate, and end up with a complicated function that requires a lot of algebra to simplify, and it's tempting for a lecturer to gloss over the algebra or trigonometry. If your algebra and trigonometry are a bit rusty, this can make the solution difficult to follow. Prof. Fowler never does this. He always works out the algebra and trigonometry step-by-step, so I never was lost trying to follow a problem solution or a proof. Staff participation in the discussion forums is higher than any other MOOC I've taken. Ask a question in the forums, and you're very likely to get a helpful response from Prof. Fowler or one of the other members of the team. I'm greatly looking forward to future math classes from the Ohio State team.
This is my favorite class I've taken so far at Udacity, and in terms of quality it's up there with Martin Odersky's Scala class at Coursera, though it is more difficult. The problem sets are very challenging. This is not a class for programming novices, though you don't need to be a Python expert. I just picked up the language as I went along. This class will stretch your mind, and make you a better programmer, no matter what language you program in.
I was a physics major my first semester in college, so I had learned this material before - twenty years ago. This class was a nice refresher of classical mechanics, and helped me a lot when I took Introduction to Astronomy at Coursera. I think it would serve equally well as a "prefresher", if you have a required introductory physics class that you want to be well-prepared for. If you have a good grasp of algebra, you should be able to complete this class. The lectures are engaging, and are broken up into very small, easy-to- digest chunks.
This was the first MOOC class I ever took, back in the fall of 2011, and it's still one of my favorites. I've worked with relational databases for over ten years, and I still learned a lot. If working with relational databases is part of your job, I highly recommend this class.
Taking a class about Scala from Martin Odersky is like getting to take a class on Python from Guido van Rossum, or a class on Perl from Larry Wall. If you like to learn new programming languages, you should not miss this class! (This is NOT an introductory programming class, and would not be appropriate for a novice programmer.) The assignments are clear but challenging, and you're provided with unit tests, so you'll know whether your code works before you submit it. The assignments for the last two weeks are rather time-consuming. My only complaint about this class is that the Scala plugin for Eclipse, which you are required to use, was a bit buggy, but perhaps they've ironed out these issues since I took the class in the Fall of 2012.
In spite of its title, this class seems like more than just an introduction. The material starts with the local solar system, and makes its way out in space to the furthest reaches of the known universe, and in time back to the first fraction of a second after the big bang. The video lectures are first rate, and the instructor is enthusiastic about the material. But the homework is difficult and time-consuming. Unless you have a solid background in algebra and classical mechanics, you're not going to be able to do it. I gave up on doing the homework after four weeks because of the time commitment. But there's no reason to feel guilty about just "auditing" a class. I thoroughly enjoyed just watching the lectures, and when we got to neutron stars, black holes, galaxies, and the expansion of the universe, every single lecture was mind-blowing!