# Profile

## Sai

Student

**14**reviews**13**completed

This course goes through the whole basics of scientific computing, starting
with ODE, PDE (wave equation, diffusion equation, etc.), various methods for
solving Ax=b, then FFT, Chebychev transform, and finally finite element
method. The professor highly recommends getting MATLAB and in the lecture,
uses some functions that are not available in Octave. The lecture videos
(except for brief opening videos for each week) were from the recordings of
his actual course at U of W and about 20-30% are devoted to hands-on demo of
MATLAB sessions. (After watching all the lectures, I feel like getting MATLAB
is not a bad idea because its IDE is much better than Octave, which
essentially has no IDE. It seems Coursera "students" are eligible to purchase
a student version.) Professor Kutz is a very humorous guy, making funny
remarks all the time, and I have never got bored. His approach to scientific
computing is not to devise all the tools by yourself but to take advantage of
whatever available to you and concentrate on solving problems. He not only
covered the basic theories but also gave practical advice in using various
tools and methods. Thanks to him, I did not lose sight of the big picture
without being buried in formulae and algorithms. Like other U of W courses,
this course does not offer certificate. The assignments were in MATLAB (or
Octave), most of which I just skipped.

This course eventually let you complete a compiler for a language somewhat
like Scala. Its target architecture is a simple stack machine but some
advanced topics such as register allocation and code optimization were also
briefly covered in the lecture. You can choose to not work on the programming
assignments but I think you get the most out of this course by doing them.
They are either in C++ or in Java and you are supposed to use Amazon's EC2
(sufficient machine hours were offered by Amazon) or download a virtual
machine image and work on your local machine. Either way, you need to have
some minimum experience of using Linux. What I liked most was that the
programming assignments provided a lot of test cases and gave me instant
feedback as to what went wrong. What I did not like was also about the
programming assignments: The skeleton code seemed pretty old-fashioned and
hard to read. I worked with the C++ code but it was from a pre-STL era with
hand-written list data structure, not using "const" anywhere, etc. From the
discussions in the forum, Java skeleton code seems more or less the same.
Other than that, I am pretty satisfied with the course.

The course starts with simple returns and continuously compounded returns,
present values, then autoregressive (AR) and moving average (MA) models, and
finally covers portfolio theory and capital asset pricing model (CAPM). Basic
probability theory and matrix algebra are also covered on the way but it
seemed too lengthy to me (spending almost 2 weeks). There are plain quizzes,
quizzes that require some R (or Excel) programming, midterm, and final. Even
if you don't know much about R, you can still do the programming assignments
in R because sample source files, which are almost giving away the solution,
are provided. Some of the R techniques I learned from this course--
bootstrapping and hypothesis testing--seem useful for general data analysis
projects as well. Prof. Zivot is (was?) also a practitioner of computational
finance and I liked the occasional anecdotes he shared with us. As is often
the case with UW courses, there will be no certificate; instead they invite
you to enroll in UW's own online course, which you can safely ignore if you
are not interested. If you decided to take this course, make sure to read
"Viewing the Video Lectures" on the course page.

You can learn basic AI techniques by building a reasonably behaving Pacman
(http://inst.eecs.berkeley.edu/~cs188/pacman/pacman.html) through 3
programming assignments. The course staff did a great job providing a GUI for
Pacman where you can watch and check how your program works. It makes learning
AI so much fun! You need some familiarity with object-oriented programming in
Python because the programming assignments make heavy use of Python classes to
decouple specific game definitions and abstract search/learning policies.
According to the concluding announcement from the course staff, the sequel of
this course, cs188.2x, is planned after the next offering of cs188.1x, which
will be in the first part of 2013, is complete. The first offering of cs188.2x
will be a closed beta for cs188.1x students.

This is a graduate level course on a branch of machine learning taught by a
co-founder of Coursera. This is one of the toughest course that I have taken
so far. Prof. Koller admits that this is a tough one for Stanford students as
well. The course page indicates a workload of 8-10 hours per week but expect
to spend twice as much. The biggest difficulty I faced with was that the
instructions of the programming assignments were poorly written and we had to
consult the forum a lot to figure out what we were expected to do. The
situation was gradually improved toward the end of the course, though. Please
note that I took the first offering of this course in March 2012 and things
might be different by now. All programming assignments are in Octave (or
Matlab if you can afford it). There were 2 tracks: basic and advanced.
Programming assignments were required only for the advanced track. Here is
some statistics that I found in the forum: 44,000 students registered, 6,450
students attempted week 1 quiz, 3,070 week 2 quiz, and about 1,100 finished
the last programming assignment. Not directly related to this course but you
may find Prof. Koller's TED talk interesting: http://www.ted.com/talks/daphne_
koller_what_we_re_learning_from_online_education.html

This is a very introductory course and maybe best suited for high school
students. There was a harsh criticism of this course by a college math teacher
(http://www.angrymath.com/2012/09/udacity-statistics-101.html) and Dr. Thrun
is going to address some of his concerns in the next version
(http://blog.udacity.com/2012/09/sebastian-thrun-statistics-101-will-be.html).
MOOC is still in its infancy and I think it is a great attitude to welcome
criticism and try to improve based on feedback. Anyway, if you are thinking of
taking this course, make sure to do so after the major update.

This course starts with an introduction to quantum mechanics, develops theory
about quantum circuits, and finally explains Shor's algorithm that factors an
integer in polynomial time (a threat to RSA cryptography??). The course
information page says it does not assume any prior background in quantum
mechanics but I think it is an overstatement. Without it, be prepared to do
some study on your own. The course does provide a brief introduction but
quantum mechanics is so unintuitive that if you understand it solely from this
course, I would say you are a genius! In addition, understanding of linear
algebra over complex numbers and Euler's formula is necessary. Having said
that, this course provides a unique opportunity to learn about quantum
computation--I suspect very few universities in the world are offering such
course. This course is not for everyone but it shows the great strength of
MOOC in matching short supply and distributed demand in education. Here is
some course statistics copied from the forum: \- number of people signed up
for the course: 26K \- number of people that watched the first lecture: 12K \-
number of people who turned in the first assignment: 6K \- number of people
who turned in the fourth assignment (midpoint): 3K \- number of people who
took the final: 2104 \- number of certificates: 1523 \- number of certificates
with distinction: 373

Great course that deepens our understanding of the world that we are living
in. The course textbook is freely downloadable at
http://www.earth.illinois.edu/sustain/sustainability_text.html. This course
covers broad topics such as population, ecosystems, extinction, climate
change, energy, agriculture and water, environmental economics and policy, and
ethics. To me, these do look crucial to every global citizen and I think I
learned what I expected to learn from this course. I didn't give it 5 stars
because of poor video editing: it shows the professor just too long instead of
showing the slides.

I took this course because I wanted to see this legendary figure in computer
science live. The course material is pretty much a standard one. If you
download the power point, you realize that Prof. Ullman is simply reading the
speaker note but nonetheless I appreciated his lectures. The contents get more
and more abstract as we move from finite state automata through pushdown
automata to Turing machines but Prof. Ullman tried his best to answer
students' questions by providing supplementary "Problem Session" videos, which
was very nice. My only complaint is about the ugly Python code given in the 2
programming assignments that was hard to read.

This course is based on Chapters 1 to 3 of the textbook written by the same
professors (http://algs4.cs.princeton.edu/home/). Frequent use of animations
that simulate algorithms step by step made it so easy to understand how they
work. I took this course mainly to learn about Java (I knew C++). All the 5
programming assignments were in Java and Coursera submission page gave you
detailed feedback as to which tests passed or failed, etc. I found every
assignment well thought out and often dealing with an interesting problem of
its own, for example, percolation (using union-find tree) and 8 puzzle (using
stack for solving a simple AI search problem). On the other hand, quizzes were
very boring where you were asked to simulate the algorithms taught in the
lecture by hand (e.g., what does the input array "SDHFIENCPV" look like after
5 swap operations in quicksort?). Since it is Princeton University's policy
not to offer any kind of certificate in Coursera (at least up to now), it
doesn't matter at all if you skip them, though. I believe Part II, which
starts in November, will cover chapter 4 through 6 and am looking forward to
it.

This course covers various technologies behind big data companies such as
Google and Yahoo. It puts higher priority on breadth rather than depth. Topics
covered in the first 5 units include PageRank, basic machine learning,
MapReduce, and storage infrastructures (Google file system, BigTable, etc.).
There are 3-4 more units left that will be mostly about machine learning. The
course is simultaneously offered to some institutions in India but online
students will not get certificate. To me, the biggest downside of this course
is that the instructor, who is affiliated with an IT consulting firm, is not
willing to share the lecture slides with the students so far, claiming
copyright issue or something. That led to some students' voluntarily taking
screenshots of the lecture video, compiling them, and sharing them for other
students. There was 1 programming assignment about MapReduce (in Python).
[Update on Nov. 9, 2012] \- The slides were released a week before the final,
thus bumping up the rating a little bit. \- The course staff changed their
mind to offer certificates to online students. \- There were 2 more
programming assignments, one of which offered an interesting insight about how
SQL can be used to compute probabilities in Bayesian networks.

The lectures and programming assignments give a lot of examples about what kind of algorithms are applicable to solving specific problems. I am not particularly interested in participating in coding competitions. Rather, I wanted to improve my coding skills in Python but found the assignments frustrating in two ways: (1) same execution time limit is imposed whether you submit your code in C++, Java, or Python -- the instructors admit some of the problems are not doable in Python due to this limit, and (2) your code is graded all-or-nothing basis, that is, if you miss a single test case out of dozens, you get zero point. These are simply how grading is done and should hopefully be made more friendly to learners (especially Python users).

This course covers the basics of numerically solving ordinary and partial
differential equations. I like how it picks interesting problems from physics,
biology, engineering, and social sciences and shows you how they are
formulated as ODE or PDE. The assignments are in Python with some help from
the NumPy library (http://www.numpy.org/). If you are interested in more
advanced material, I recommend to take a look at Coursera's Scientific
Computing (http://coursetalk.org/scientific-computing-uw).

I have been using Python for 5 years at work and in my personal projects but
this course was truly an eye-opener: there are tons of ways that I was unaware
of to use this powerful programming language to attack problems. It was a very
pleasant experience to watch how elegantly Dr. Norvig uses Python to solve
games and other computer science problems. I am sure that even more seasoned
Python programmers than I would share this feeling with me after taking this
course. If you are interested, you can watch Dr. Norvig's thoughts on MOOC in
his TED talk at
http://www.ted.com/talks/peter_norvig_the_100_000_student_classroom.html.