Category: coursera

More Coursera courses

In the recent months I participated in more online courses on Coursera. Once again it’s time to share some impressions. If you care only about functional programming I suggest you skip directly to Programming Languages section of this post, but I highly encourage to read reviews of two other courses as well.

Think Again: How to Reason and Argue

Some time ago I’ve been quite interested in proper ways of arguing and in spotting logical errors in argumentations. Needles to say when this course was announced I enrolled without hesitation. It looks that this subject draws a lot of interest since this was in fact one of the most popular Coursera courses to date. The course lasted 12 weeks, which in my opinion is very long for an online course – even Compilers took only 10 weeks. The course wasn’t very time-demanding, taking about 2-3 hours a week to watch the lectures and possibly another hour to complete the homework. I didn’t get the textbook so I did no additional reading but I guess this would take another 3-4 hours a week.

The course was divided into 4 units. Unit 1 was about analysing arguments: identifying premises and conclusions, separating relevant argumentation from verbiage, distinguishing between valid and invalid arguments, rephrasing the arguments and so on. I’m good at pure sciences and not really good at humanities so this unit was a bit hard for me. Still it was interesting. Unit 2 made a turn towards propositional and categorical logic. This on the other hand was easy for me, but I felt this was only dry theory and there was no demonstration how to apply it in analysing or giving arguments. Unit 3 covered inductive arguments, causal reasoning and probabilities. Once again the material was easy for me and interesting, but it wasn’t placed in a larger context and few applications were demonstrated. Finally Unit 4 focused on logical fallacies and refuting arguments, which are the topics I’ve been waiting for the most. The presentation of material was very good and I had the feeling I understand all of it, but when it came to tests it turned out that I actually have problems with applying in practice what I have learned. This was a bit frustrating. Oh well, I guess I wasn’t born for the humanities.

Think Again was the most fun online course I have participated in so far. This is mostly thanks to the great lecturers Walter Sinnott-Armstrong and Ram Neta, who put a lot of work and energy into lectures to make them both interesting (even entertaining) and informative. I think few things could be improved in this course. When it is redone in late August (that’s the current plan) I highly recommend it to anyone

Heterogeneous Parallel Programming

The subject of Heterogenous Parallel Programming was parallel programming in CUDA. This is a subject I got interested in recently so I decided to participate. While Think Again was one of the best online courses I took, this one is by far the worst. It’s hard for me to explain how big disappointment this course turned out to be, though perhaps I shouldn’t be so harsh on it because I decided to quit during the third week.

Heterogenous Parallel Programming was supposed to start in early September. It was delayed by almost 3 months and began at the end of November but even then it was clear that the course is not yet prepared. There were numerous technical issues with the online platform used for homework submission though this can be forgiven. What I find unacceptable however is the delayed delivery of the course material. The delays resulted in extending the course from initially planned six weeks to eight weeks, which some people on the forums have complained about and I totally agree with them. I know that it’s hard to take many online courses when they overlap and extending the course by two weeks might be a real issue. I also found the level of material covered in lectures to be unsatisfying. The course assumed knowledge of C. Still, lectures focused mostly on discussing very basic C language constructs and algorithms, e.g. during first week one lecture gave a lengthy explanation of converting index of a two-dimensional array into a linear index. Come on, this is basic C! If it was assumed that participants know C why go into details of such a basic algorithm? This was in fact the problem with many lectures I’ve watched. The pace was slow and the focus was put on C instead of CUDA. Sadly, all the lectures ended with the information that in order to learn more I need to read the book. Perhaps unsurprisingly the book is authored by professor Wen-mei Hwu, who is also lecturing in HPP course. This was really disappointing and I decided to drop out of the course when I realized that I would learn a lot more about CUDA if I spent three hours a week reading the documentation and tutorials instead of participating in this course. There were lots of other minor annoyances: course staff decided not to use the standard Coursera interface and instead created their own, which often had mistakes and broken links. While most courses send 1-2 emails a week, the staff  of HPP kept spamming the participants with tens of irrelevant emails a week (up to four a day), notifying people that “we just enabled some option” and two hours later “we changed some layout” and so on. Luckily the notifications can be turned off, but this also means you won’t get the relevant ones.

So is there anything good to be said about HPP? Luckily, yes. Professor Wen-mei Hwu was very responsive and replied to many objections people have raised in the discussion forums. As you see from the above review I am not convinced by these explanations, still it’s a big plus that he took part in the discussion. I don’t know how this course has ended. I guess that you can learn CUDA from it if you really want but judging by the first weeks of the course it’s better to just grab some online tutorials.

Programming Languages

Programming Languages is a currently ongoing course that covers different aspects and features known from various programming languages. The topics include recursion, scoping, higher-order functions, pattern matching, algebraic data types, parametric polymorphism, currying, type inference, laziness, memoization, macros, inheritance, mixins and many more. As you may have noticed most of these features are typical to functional languages and indeed the courses focuses on functional approach to programming. Languages used in the course are SML, Racket and Ruby, though the course is not about these languages per se – they are only used to demonstrate various features a programming language can have.

The course is very demanding. During 10 weeks there will be eight sections of the material. Each section has usually over 3 hours of lectures. It takes about 4-5 hours to watch them due to the breaks you will likely take between the lectures as well as the time needed to test on your own the demonstrated code. Homework is also time-consuming. It took me about 3,5 hours to complete the first assignment and 2 hours to do the peer review of other participants’ solutions (that’s part of the grading). I think this is quite a lot given my background in functional programming. Others have reported times of up to 12 hours and I know many people have given up on the course because of the difficulty. I myself have given up not because of the difficulty itself but simply due to the lack of time. Sure, learning more about SML and Racket would be fine but I’d rather spend those 8-12 hours a week working on Haskell. I still watch some of the lectures that cover topics that interest me.

While I think that making the course material challenging as it is now is a good thing I don’t like the strict policies about deadlines. There are about 9-10 days for each assignment and the hard deadline comes only two days after the soft one. Given that the lectures are released in the middle of the week, people working full-time will have to put a lot of work to successfully complete this course. That’s a pity, because the course is awesome and relaxing the deadlines would make it accessible to a wider audience without lowering the quality of material. Still this is a highly recommended course.

Some thoughts about Coursera

After completing Compilers and Automata courses on Coursera I am participating in yet another course: Writing in the Sciences. I guess the name is pretty self-explanatory but just to make it clear: the course is about writing scientific articles. This is something I definitely need as a scientist for my work. I never considered writing to be my strong skill so I look forward to completing this course. Writing in the sciences is lead by professor Kristin Sainani. It is a well-known fact that fun from learning depends not on the subject itself, but mostly on the lecturer’s ability to present information in enjoyable and interesting way. Professor Sainani’s lectures are a great example of that, in contrast to professor Ullman’s lectures on automata, which I personally found a bit dry.

That said, I guess I have a few reasons to complain about the course and Coursera as a whole. While lectures given by professor Sainani are interesting, it is sad that she practically does not participate in the forums. I know that it probably takes a lot of time to prepare the lectures, but still I’d expect the lecturer to spend an hour on the forums once every 5-6 days. While the forums are for the students to help each other with learning, there are some issues that must be resolved by course staff. A good example is a problem with downloading one of this week’s lectures. It was reported on Monday and after two days the problem remains unfixed despite numerous complaints on the forum (to make things worse, this lecture is about assignment that is due to the end of week). Another thing that makes participation in the course more difficult is publishing new material on Mondays. I have a lot of time on Sundays so I could easily watch new material on weekend and do the homework during the week. That’s how it was done in Compilers course. With videos released at the beginning of a week I have problems with finding time to watch them and even more problems with doing the homework. Again, there was request on the forums to release videos one day earlier, but no response from the course staff. I am also very sceptical about the grading methods. With compilers or automata it was easy to design tests. In Writing in the Sciences it is not that simple. During the weekly tests students are asked to rewrite some fragments of scientific articles, but this cannot be graded automatically. I personally find these tests difficult. I usually come up with answers that I consider great, but after comparing them to model answers I am mostly thinking “why didn’t I figure this out”. Oh well, I guess that’s what learning is all about. I also wonder how the upcoming peer-review will work out. The plan is to have students review each others homework assignment (a short review of a scientific paper). I’m afraid that this may be a failure. One unfavourable factor is the time needed to review five different papers. Another one is that people come from different cultural backgrounds, know English on a moderate level and, saying straight out, often seem to misinterpret intentions of the writer and the message he/she is trying to convey (I’m judging from the forums and not trying to offend anyone).

While not getting feedback from professor Sainani is a problem of one particular course, I noticed that a general problem of Coursera is lack of any kind of technical support. Sure there is an address to technical support, but I have never received any kind of reply despite reporting a couple of problems. I am aware that Course is dealing with over a million participants and it is impossible to respond to every mail, but it wouldn’t hurt them to send at least an automatic “we will look into your problem” response. Since I never got any response and I don’t see the reported problems fixed I feel as though my mails were being send to /dev/null.

Another reason to complain is Coursera’s lax approach to announced time schedules. I already learned that despite being announced, courses get delayed and even cancelled. I understand that a one week slip is possible, but how can it happen that a course is planned for early July and it hasn’t started yet? It seems that someone who planned the course didn’t take his job seriously.

With all that said I still think that Coursera is a revolutionary approach to education. All it needs is just a bit more work and a bit more involvement.

Some impressions on Stanford’s Automata and Compilers online courses

Over two months ago Stanford opened first edition of online courses on Automata and Compilers (see this post). I’ve participated in both. These courses cover basics of each discipline and assume no previous knowledge of the subject. Now the courses are over and it’s time to share some impressions.

Automata course was six weeks long. It consisted of lectures and so-called homeworks, which are quizzes that should be taken every week. There were some optional programming assignments, but they didn’t affect the final score. The topics covered were: finite automata (deterministic, non-deterministic), regular expressions, context-free grammars and languages, Turing machines, decidability and finally P and NP problems. The course closely follows the book “Introduction to Automata Theory, Languages, and Computation” by John Hopcroft, Rajeev Motwani and Jeffrey Ullman. This shouldn’t come as big surprise, since the course is lectured by Jeffrey Ullman, one of the authors. For the first three weeks this course very closely followed Compilers, as both discussed automata, regular languages and context-free grammars. I initially enjoyed Automata course a lot, despite lectures being a bit boring. I just read the book and then skimmed through the lecture slides. Sadly the last two weeks of the course were extremely hard to follow. Lectures were rushed and impossible for me to comprehend. Reading the book didn’t help a lot, so I didn’t understand much of decidability, P and NP problems. That said, I’m still very happy with this course, since automata and context-free languages were top priority for me. Keep also in mind that this is very subjective opinion of mine. Reading posts in the course forums I saw that there were really mixed opinions. Some people complained about the lectures being hard to follow, but others praised them for being interesting.

Compilers course took 10 weeks and was much more demanding. It covered theory of lexical analysis using automata, top-down parsing using recursive descent algorithm, bottom-up parsing using LL(1), SLR, and LR algorithms, semantic analysis, operational semantics, code generation, optimizations and garbage collection. Believe me, that’s a lot of theory! In contrast to Automata course, it was all presented in very accessible and interesting way. Each week contained up to 3 hours of lectures and a theoretical quiz covering presented material. There were also four programming assignments which required to implement four different parts of the compiler: lexical analyser (a.k.a. lexer), parser, semantic analyser and code generator. First two exercises relied on existing tools for generating lexers and parsers. The language implemented was COOL – Classroom Object-Oriented Language. I consider programming assignments to be demanding, especially the last two. Third took me about 25 hours to complete. I didn’t manage to finish the fourth one, but I’m still satisfied, since I’m interested mostly in the front-end parts of the compiler (type checking especially). The best thing about Compilers course is that it was motivating. It encouraged me to finally read some chapters from the Dragon Book and “Engineering a Compiler”. Which reminds me that I promised to write more about compiler books.

The Dragon Book turned out to be surprisingly interesting. It is verbose and very dry, so it’s not suitable for reading from cover to cover. Nevertheless, if you have a general idea of what is going on in the compiler and need details on some particular algorithm this is an invaluable resource. In short: bad for introductory text, perfect for reference.

“Engineering a Compiler, 2nd edition” is different. It is very accessible comparing to the Dragon Book. In every chapter the reader is given a clear outline of what will be done and rationale why some particular theory is needed. This greatly helps to understand what’s going on in each phase of compilation. At the end of each chapter there’s an overview of literature on a given topic, so it’s also a great starting point for deeper research into each subject. Thus I think that book makes a very good introductory text. I wholeheartedly recommend it.

I haven’t read Appel’s “Modern Compiler Implementation in C” so I really can’t tell much about it. Hopefully I will find some time during the summer holiday to read the chapter about Hindley-Milner type inference algorithm.

Coursera online courses were an awesome experience. Challenging and time consuming, but also very motivating and rewarding. I’m waiting for more courses in the future, especially for the new edition of the Game Theory course.

Staypressed theme by Themocracy