Positive things: - There is no doubt that Professor Edwards is very knowledgeable about his field and really cares about helping students who are reaching out to him and want to learn from him. - He holds 167468294 office hours a week, so take advantage of them. - He responds to emails in light speed. Areas of improvement: - If you're going to constantly run over the end of class time, you might as well ask the CS Department to make your class 2 hours long, so people have better expectations. Although that would require Edwards to deal with bureaucracy, which I'm pretty sure he won't bother with. It's much easier to fuck with student schedules for him, but it irritates the fuck out of every student. - Set a deadline for grading for your TAs, man. It's not that hard. - Please get TAs that actually know OCaml... Negative things inherent to the course: - Pick a good team or you'll get fucked. The project is monstrous and you can't do it alone. You need good teammates to decide on the project features together and implement them together. - I understand that Edwards tries to teach a lot, which is why we have individual assignments, midterm (normally, it was canceled this sem), final, a monster project, a ~250 page final paper on the project... but man, this is a lot of work. If you're not ready to put in the hours, don't take this class. - Docker and OCaml can be very frustrating, but they will uncover new areas of software development for you. Advice: - Test everything. He won't accept anything that's not tested. - Start the project early. - Edwards is snarky, don't take it to heart. - If the assigned TA is useless, stop wasting your time meeting with them immediately. - Trust Edwards in that when he's giving project advice, he's thinking the best for you. He's also not out to get you in the exams.
Ok first I took this during a COVID semester. With that being said, I personally don't think Edwards taught. He kinda just read off his old slides and circled some things. I also think we spent way too long on the wrong material and then suddenly material in the middle-back half of the semester was essential to the final project. It was hard to start parts of the final project early since we didn't know a lot of the material needed to actually build our language.
Stephen Edwards is objectively an outstanding professor who made the online year a little better for me. I took both of his classes, and I thought he adopted to the online format very well (he makes great use of Zoom's chat feature for questions). He is incredibly organized, cares a lot about his classes and his students, and has some outstanding TAs (Ben Flin and Hans Montero were amazing). Not to mention, he is one of the only Professors in the CS department who actually tries to get to know undergraduates in his classes! I really appreciated this and feel like I actually know him now. Oh, and did I mention that Prof. Edwards is absolutely hilarious? I think the quotes above will suffice, but his slides have great memes, his Facebook might be the most entertaining of any Professor's, and he is incredibly witty. If you enjoyed Donald Ferguson's snarky humor, Professor Edwards is for you; if you have a thin skin, you might want to stay away, since he will absolutely sass you back. I, personally, think it is wonderful, and I think most people do as well. As for the actual classes, Parallel Functional Programming is an introduction to programming in Haskell. The first half is sequential Haskell and the second half is parallel Haskell. Haskell is nothing like other programming languages you have been exposed to (unless you have taken PLT and are used to OCaml), and it probably does warrant an entire course since it forces you to think in an entirely new way. There are 5 HW assignments and a medium-workload final project that you spend the last month or so on and do in groups of 2. I'd absolutely recommend this to anyone looking for a chill class, even if they aren't on the systems track (Edwards has said this is similar to a 41xx class). Programming Languages and Translators is an introduction to Compilers, and for many students, functional programming with OCaml. I was at the advantage of having taken PFP beforehand so this wasn't a huge jump for me, but it is for many. You also learn some theory. There are 3 light-ish HW asignments, a final, and a very heavy group project that you do in teams of 3-5. Pick a good group! I believe both classes were curved to a B+, so it is very possible to do well. I cannot recommend Prof. Edwards any more than I already have; seriously, take a class with this man! If for nothing else, the memes are worth it.
Great class. Some issues with the curriculum: we spent way too long on things like DFAs, NFAs, and regexes, which are covered pretty fully in CST, which is a prerequisite for this class, so that was a bit of a waste of time. We also spent a bit too long on covering code generation, which became repetitive, so we did have to rush a bit at the end. But codegen is really important for the project, so it shouldn't be ignored, but spending ~5 classes on MicroC codegen was a bit much. Edwards is a great lecturer. He's very funny and presents the material in a way that makes it very conducive to picking it up rapidly (or wickedly fast, as he would say). His lectures were actually a joy to go to. The best part of this class imo is the project, though. One of the most rewarding pieces of work I've done at Columbia. It really is a great synthesis of all the course material, and juts is a lot of fun to work on. Start work early, and work consistently. It will be a great time.
I think Edwards is generally a good teacher. His office hours are really helpful and his HW assignments and exams are reasonable (most questions are basically the same as the HW questions except for one or two. The slides are super helpful and it was a good class to take over Zoom because I was able to rewatch a bunch of his lectures if I was ever confused. He's a pretty good lecturer, except that on Zoom he lets and encourages people to make random show-offy comments with inside CS jokes that are distracting, annoying, wastes time, and makes everyone who doesn't get them feel dumb for not knowing the conventions of some obscure language. We get it, Matthew Ottomano, you know Haskell. In terms of the group project, it's very tricky, and you don't really get taught the material you need to do it until after you had to do it, and even once we learned the theoretical part of what we were doing, it was really hard to translate that to what we were implementing. Basically, you're very much on your own for figuring out to add features to your language beyond a basic C like language you're given as a starting point. For our group it wasn't too bad, but it's mostly because one of the people in our group clearly understood everything way better than the rest of us did and did a ton of the work. I'm not saying the rest of the group were slackers, everyone tried hard and put in a lot of hours, but we'd struggle to pair program a feature for hours and then the other person in our group would have just fixed it and also miraculously added a bunch of other features by the next time we talked. That said, the group you are with is super important. I don't have great tips about how to find a good group. Someone who you think is super smart is not necessarily the best teammate. It helps if you've worked together before and understand their workflow and work ethic. It's pretty cool to have a finished product by the end, but I don't even know how much of it I understand beyond the features I implemented. Actually even those I feel like I kind of stumbled around in the dark in making them, so I don't know if I actually understand them either. Finally, the TAs were not great in the class. One was fired apparently half way through the semester, some didn't seem to know Ocaml or really how to help with the project. I think it was partially because Edwards hadn't taught the class in a while, so he didn't have a super solid group of TAs that had taken his version, which I understand, but was kind of frustrating. Overall, this wasn't the worst class, and I would generally recommend taking it with Edwards. Your group will be the main determining factor on your experience taking the class, though.
Edwards is very prepared and cares a lot about the students, the course, and his TAs. He is engaging, funny, and not monotonous, but nevertheless his lectures are a bit awkward and hard to follow. That's because he mostly just verbalizes the symbols on his slides. E.g. If there is an arrow from A to B on a particular slide, he would just say "x moves from A to B". To improve his lectures, he could repeat what he is trying to get across more times (so we can have time to think about why x would move from A to B, and be able to more easily do problems of that sort) or actually elaborate on the reasons behind the actions that happen on his slides, to students.
Professor Edwards is an awkward turtle, but likely one of the best lecturers I have ever had. This course is a heavy amount of work, but I can't imagine someone better to inspire a passion for programming language design as well as compilers (although he himself recommends Aho). Like everyone said before, the final project is a monster, it's really the whole course in one project. That being said, this is one of those classes where almost all the theory you learn in lecture can be directly or indirectly addressed by the design and coding of your project. Everyone says to pick an amazing team, which if you are like me and took the course your first sem in Columbia, is like saying try really hard to get lucky. Nevertheless, whoever your team may be, it pays off to work on your project incrementally and try to get everyone involved as early as possible. In the end, I think he mentions almost all projects get good grades although you'll have to work hard on yours. TL;DR: Take this class if you're really interested in the subject matter. Not a good class to tack on for a GPA boost or to check off a requirement.
Professor Edwards is fantastic. He is engaging, funny, and extremely smart. This was a really great class, and I learned a ton. That being said, the project is definitely a ton of work, so start early! The material that you learn in class doesn't help much with the project itself. So, don't worry about starting the project before you feel like you learn the relevant information in class, because you likely will learn the information way after you need to already have applied it to your compiler.
Proffesor Edwards' is a world-class lecturer! He has complete and absolute mastery over his material (feel free to ask him about any possible tangent, he'll answer you). He is refreshingly down to earth and very humble, all around a gem of a human being. It is obvious that he loves lecturing, and puts himself fully into it. Lectures are somehow very easy to pay attention to as he's always able to keep it exciting. -A huge fan!
This is one of my favorite classes at Columbia. This is one of the very few classes where both theory and application of computer science comes together. And the manner in which Professor Edwards teaches this class is incredible. Professor Edwards is very organized and well prepared for lectures. His slides are very comprehensive and lectures are very clear. On the side note, he also brings in "Stephen Colbert" style humors in class which can be quite entertaining at times. The project is the centerpiece of this class. It allows you to build a programming language on your own from scratch. This can be a great experience because you are dissecting every component of the building blocks of a modern programming language. Much has been written about OCaml which is the language used in the project. But half way through the semester, everyone realizes that due to its very important features like pattern matching and strict type referencing, OCaml is simply the best language for building a programming language in a semester long period. There is also a huge inventory of past projects done in OCaml in the class website that can be very useful reference. Some people who had taken this class with Professors other than Edwards often ran into challenges due to lack of resources and reference materials. I highly recommend taking this course with Professor Edwards. Make sure to find good teammates and make use of past projects as a guide. You will end up with a great project and your own programming language. The things that are learned in this class such as project management, teamwork, testing, leadership have applications for rest of the CS career.
Stay away from Edwards, go with Aho. Edwards recommends Aho himself. Also, Aho's famous because he's the A in AWK and wrote the Dragon book. The only thing you'll miss in Aho's class is Edwards' sense of humor. Edwards is the snarkiest, most sarcastic, immature professor you will meet in the CS department. He tells some really great nerdy jokes and his Facebook wall is hilarious since he belittles all his students publicly on it, but I don't recommend taking his class. Don't ever email him with an excuse or stupid question since he will publicly shame you (name removed though) on Facebook. I didn't learn much in the course. The material was pretty straight forward, nothing really complicated like you would see in more theoretical CS classes. You sort of get a high level understanding of how a compiler works and that's about it. If you did most of the work for your project, you will learn more mostly by reading on your own to save your project and not because you learned anything from this class. His exams are reasonably easy but the problem is everyone gets high scores. The median on the midterm was like a 94. If you screwed up even a little bit, you were done for. You don't have to know all the material in the slides - most of it is to build the compiler. He posts review slides the class before the exam. You just need to know the stuff on them. Check out the last semester slides on his website to peek ahead. Grading was harsh and he often cuts points for really dumb reasons. Make sure your HW is perfect if you want a good score. The project is KILLER. In all likelihood, you will fail if you don't assemble the Avengers to be your team. Make sure you put together a strong team which has time to commit to this project. The project is structured such that one person (the most responsible or the least busy) always ends up doing over 50% of the work. We've looked at other groups and previous teams and this is the case through out. I think Edwards should take a look at this and somehow fix the project so that it's more fair. Some tips: Start early!!! Get the scanner and parser out of the way quickly. You can copy most of them from last year's groups and just modify them to your liking. He doesn't really teach you enough to write the compiler till 3/4ths of the way into the semester but don't wait for that since you'll get screwed. Semantic checking and code generation take a ton of time to complete. Start early and be sure to pester the TAs for help. Also, half of you team will be slackers and you will lose all faith in humanity. You just have to deal with it. He doesn't make expectations on the project clear at all, so I'm going to break it down for you here. You need to turn in your proposal 2-3 weeks into class. Get started with the scanner and parser ASAP. Then turn in your language reference manual which says what your language will look like. Then code up the rest of your compiler and put together some tests. Our group ended up writing 70% of our language during reading week and finishing the slides for our final presentation and the project report during finals week. Needless to say, my other exams got screwed in the process.
Really interesting content, not necessarily taught that well. Writing a compiler is an amazing experience, and if you start early, you should be fine. I went in with no functional programming experience, and really enjoyed learning OCaml and the functional paradigm. I'd definitely recommend the class: at the end you'll have written your own programming language! START EARLY, and really be selective in picking your team. A bad team will ruin the semester for you.
This review is for Edwards and for the SUMMER version of PLT. There is no summer review of him on here so for those of you who were curious, read on! Edwards is, plain and simple, the shit. He is quite possibly the most organized professor I have ever seen. His website contains every class of PLT he has taught for the most part including old projects, slides, and documents. Furthermore, his notes are outstanding. In that regard, he has basically done all the work for you. The material is complex at heart but his notes and his descriptions in class make that material very easy to digest. Furthermore, it is evident in every shape and form that he absolutely loves and cares about the material. This man is among the nerdiest to ever exist and he definitely knows his stuff inside and out and forwards and backwards and I feel like he was very effectively in conveying this passion in his lectures. In addition to learning about making a language, you will also learn cool tidbits like C history, language history, or operational details you might not have known about various languages. Edwards is also a total language hipster and spent the first day of class openly trashing Java, C++, and many others (he called Perl an "abomination"). Therefore, if you are waiting for his endorsement of the "cool and underground language you haven't heard of, maaaaaan" then you will find it with OCaml (more on that in a second). The summer class had two homeworks which were both incredibly easy. The notes will tell you everything you need to know and he doesn't pull any cheap shots; if you pay attention in class and understand the notes then you will be able to breeze through the assignments. However, the homeworks are only 10 percent of your grade. A whopping 50 percent of your grade comes from a massive project wherein you have to make your own programming language. The other 40 comes from the final exam (no midterm) which, while a little tricky, wasn't too bad. The project itself MUST be done in a language called OCaml which I had never heard of before taking this class. OCaml is quite possibly the most annoying language you will ever use if only because it has the most frustrating and nitpicking compiler I have ever seen......but the good news is that most of the time once it compiles then it works the way you want it to. Personally, I prefer to write code that blows up, analyze it, and then fix it (and isn't that the purpose of test suites anyway?) but you will have no such luxury with OCaml. Furthermore, it has very unhelpful error messages; it is fairly difficult to ascertain the problem when the only indication of what you did wrong is something like "Syntax Error" or "Expression was 'a * 'b * 'c but was expecting type 'a * 'b list" (and what the fuck exactly is a 'b list?!?!? I just finished the class and I still don't know). If you thought "Segmentation Fault" was bad just wait until you get a load of this. Still, Edwards makes the point that OCaml is an easy language to write compilers in and once you start getting good at it you will see where he is coming from. The language itself is fairly powerful and you can do quite a lot with only a few lines. As annoying as OCaml was I am glad that we had to use it if only to a) learn a new language and b) gain the new perspective and discipline from programming in it. It is also interesting to learn a new language when taking a class dissecting what makes a language "good". START EARLY ON THE PROJECT. The class is 6 weeks long and goes by faster than you'd ever believe. My team and I were pretty good at staying on point throughout but I can very easily see how the project can be a nightmare if you wait until the last minute and doubly so if the team hasn't practiced with OCaml. There were other teams demoing with barely finished languages who appeared to make that mistake; don't let it be you. The only complaint I have about this class is the time we spent covering Prolog. While it is an interesting language to learn about, I don't know why he spent the time he did covering unification and searching considering AI is already a class here. This part of the class seemed completely out of place and irrelevant next to anything else we had done all summer. There was even a Prolog question on the final exam. It seemed rather pointless to have this question on the final, which is supposed to test my knowledge of programming languages and translators, covering an AI topic and making it worth 10 points. Lastly, a word of warning: Edwards is a very direct person and is quick to criticize or otherwise shoot down your ideas for your project. Don't take it personally. At first he hated my idea too.
I took this course with Edwards and Martha Kim in Fall 2012. This is a review of Edwards. His slides are simple and informative. His lecture style is very straightforward: he is one of the most rational and simplistic presenters of complex material I have ever encountered. If I had to take PLT, I would do so with Edwards. He introduces LogiSim, which Rubenstein does not. I told several of Rubenstein's students about LogiSim and it made their lives much easier. But really I'm writing this review because of Edwards' personality and humor. Edwards is a geek's geek. Perhaps he doesn't look like one, but he dresses like one and behaves like one. I find this enjoyable in a professor, but for some it may be an acquired taste, like Scotch whiskey. Some co-engineers of mine have pointed out that he can be rude, surly, and dismissive. I think these attributes seem to present themselves because he is rational above all else, and has a limited amount of time. (~2 orders of magnitude below Temple Grandin. Let's say the average engineer is about 4 below, Vallancourt is 6 below, and the average art history major is 10 below.) I don't think he has ever been rude to me, but in the sense of being hyper-analytical without regard to feelings, Edwards has a tendency to do this. And I personally find it liberating, assuming I am capable of keeping my ego out of the equation. I wouldn't say he equates human interactions to a set of logic gates, but in dealing with assignments and career advice, don't expect a lot of small talk or beating-about-the-bush. Professor Edwards is one of the most direct human beings I have ever encountered. If you need to prove to yourself that he has a soft/creative/dynamic side, keep in mind the following: * He modeled for McDonald's in Taiwan * He bought a vintage PacMan arcade machine and drove it to his office from AC * He makes bad jokes that pertain to driving even though no one drives in New York * He wears a fanny pack when he bicycles to and from Mudd I may not be the most adept engineer in SEAS, but I thoroughly appreciate Edwards' awkward and dryly amusing brand of brilliant.
Prof. Edwards' sense of humor is really quirky. As the reviewers below noted, it could be quirky to the point of being a little bit embarrassing. However, I fundamentally disagree that his humor took away from his teaching. He is by no means a perfect lecturer. He isn't charismatic like Gulati, thorough like Vallencourt, nor approachable like Blaer. However, he still kept the lectures interesting and got the material through to the students. It definitely could be that PLT (which the reviewers below took) and fundamentals are fundamentally different in difficulty. However, if you see yourself having to take Fundamentals with Prof. Edwards, I would say go for it, but be ready for a barrage of quirky humor from your first day.
A word on Edwards. He would spend a good deal of time telling jokes that apparently he found funny. Humor can be a great teaching tool, but this isn't the Laugh Factory, it's a university. The topics covered in this course are difficult, and having to listen to the professor joke his way through his lectures is irritating and frustrating. As for his metaphors, I have heard people tripping out on drugs make more sense. If you have no experience with functional programming do not take this course. Read up on lambda calculus and OCaml (which he has a huge hard-on for) before you even entertain the idea of taking this course with Edwards.
I found Prof. Edward's sense of humor painfully annoying and his teaching rather scatter-brained. The topics he covers are all pretty interesting, though, and since the only other option for this class is Aho, I'd definitely go with Edwards. By far the most educational part of the class was the project in which we had to create and implement a programming language in OCaml. However, learning OCaml was a bitch and made my team yearn at times for Aho's section (you get to use Java). Also, Edwards didn't really ground us in the theory well enough for us to create our own compiler until about 3/4 of the way in to the semester, which made the end of the semester hellish.
I personally like his interesting sense of humor, but some find it annoying. As a transfer student, I feel he gave the other side of programming languages than my other class which was more theory-based -- one down side is that he doesn't know that much about the lambda calculus, which seems to be a big hole in somebody teaching programming languages. In terms of teaching the material, lectures can be a bit scattered but always have great information. His homeworks and exams are more than fair as they are straight out of the lectures. If you are in his class, attending the lectures will make you do well in the class.
I don't know what to make of Edwards. I like the guy, and I'm *pretty* sure he's a good professor. But I can't prove it. Edwards knows everything about language design; he's funny and relatively friendly. He keeps the lectures interesting, sort of -- but by the end of the term nobody went to class. For one thing, ONE annoying kid managed to ruin the whole term by asking ridiculously irrelevant questions every five seconds, and Edwards never really tried to shut him up. So the lectures kind of went to shit from that point on. But! PLT is super-intense and is probably the first (well, maybe OS) 4000-level course that actually kicks your ass. Personally, I like this. You work in groups and design a language; if you're like us, you leave it until reading week and then just live in the CLIC lab for a few days. You can do it, but it's a bitch. Anyway, you're just choosing between Edwards and... what, Aho? for this class, so choose Edwards.
PLT is a very dry subject, especially when taught using reams of slides. However, Prof. Edwards is very funny and made the class very interesting. He has a warped sense of humor and would spice up the lecture notes with hilarious pictures. Here are some of his famous lines: "hangs like a criminal", "a lazy approach gets you out of infinite work", "Things are always in the last place you look. Of course they are! You always stop looking once you've found it.", "Union is like a structure except its schizophrenic", "Symbol table is like a roach motel, you can checkin but you can never leave", "computer scientists are smart asses", "if thy arc offends thee", etc. etc. Oh, to my great delight Prof. Edwards would often preface a topic with "this would make a great exam question...". Take heed this advice!
I'll say this for Prof. Edwards: he made PLT way more interesting than it should have been. He is definitely one of the wittier professors in the CS department, so the lectures were engaging. But if you're planning on printing out slides before lecture, be warned: there are a lot of them (about 40 per class, on average). Plus, he really integrates his own research into the lectures, as opposed to just plugging it like other profs. Central to PLT is a group project in which you get together with three other people and implement a programming language of your own devising, which is possibly the most challenging and rewarding thing I have done as a CS major.