Whoever took this class with Shirish as TA onboard knows what I mean. Shirish shouldn't be a head TA at all, he controlled your grade and would not care for students and Gail was too busy to do any grading at all. Several students argued with Shirish many times and his condescending attitude pissed everyone off. Overall a class with good content but the assignments were too easy(Shirish made it harder by giving low grades). When Shirish onboard, jump off!
It's been six years since someone posted a review for this course, so I figured I would add one for Fall-2020. After reading the old reviews, I found that compared to the past offerings, this course has drastically changed. I recommend taking this course if you want to formally understand various aspects of software engineering. It is most beneficial for students without prior work experience. However, as an experienced professional, I have learned a great deal about software testing. The lectures were loosely structured. Professor Kaiser covered theoretical topics in-class via real-world examples, code snippets, and online resources. On many occasions, we discussed interesting topics such as autonomous driving software and testing AI systems. TAs were helpful in troubleshooting individual assignments. Sometimes Shirish (Head TA) gave in-class tutorials on tools/technologies used in the assignments. Grading mostly seemed lenient for assignments and assessments. However, you need to be very careful about the requirements of the assignments/assessments. I felt that time allocation was not managed well. The first half of the course only had individual assignments. The team project started mid-October, so we had less time to develop an MVP. The online setup of the class (Because of COVID) was somewhat helpful in terms of collaboration with peers. But, starting the project early would have helped a lot in terms of applying what we had learned to the project. Take this course if you have little or no full-time industry experience. If you want to learn about SE and software testing, then this course is great. This class is not about UI design/development. Try other classes for front-end development.
Overall, I recommend not taking this course. The ideas behind this course are simple: think in terms of the customer and plan your project accordingly. Unfortunately, a lot of the documentation we do is not really meaningful, and the pace of the class could be faster. We spend several weeks on design patterns, and another several weeks on "bug testing", which is stuff you pretty much already know. If you want to challenge yourself on your road to becoming a fully-fledged Computer Scientist, don't take this class. If you are looking for an easy course to take on the side, while knocking out your tech electives, you might consider ASE. This class is not really "Advanced Software Engineering", it should be called "Software Project Planning for Enterprise". The midterm reflected the course. It was pretty easy, with just definitions and written explanations of concepts. But at the end of the day, how much did you learn compared to a class like OS or Algorithms?
The class moves pretty slowly for a 4000 level CS class and covers the qualitative components of Computer Science (planning, group dynamics, etc). Don't let the name fool you, there is nothing "advanced" about this course. It is interesting that we get to work on a project of our choosing over the course of the semester, but the amount of documentation we have to provide beforehand is a little infuriating. You end up spending 3x more time writing out requirements, risk, etc than writing code. You will probably have to take this class because it is required for Software Systems, and let me say that this is not a "bad" class. You still learn concepts like design patterns, but ultimately you will learn MUCH more if you take a class like Operating Systems or Computer Networks.
I recommend _not_ taking this course. 70% of the work is document writing, drawing graphs, and typing stuff into JIRA, not difficult, but very tedious and boring. You do surprisingly little coding, which is ironic for a "software engineering" course. Writing "cool" software won't score you more points in the class. If you absolutely must take this course, do not be ambitious about the projected you will create. You won't receive extra points because your project is "cool" or "harder." Most of your grade hangs on the writing/documentation you do -- and you will spend more time on this than anyone would want to. So make your software easy to document and easy to test. You really only spend a month or two working on it, the rest is over-excessive planning you don't end up following anyway. The midterm and final will have you writing so much stuff! The first of the three questions test you on vocabulary (!) terms from the lectures/book. The second one is short answers. The last one asks you to come up with designs for proposed software and ask you to write more than what most people can do in the given time. If you take this course, do the test backwards. Almost everything in the course is pedestrian stuff you know already: unit tests, version control, software testing, etc. The other stuff you might not have heard of, UML diagrams, burn-down charts, and spike testing, etc, are not complicated at all, and can easily be learned from the textbook. (http://www.amazon.com/Head-First-Software-Development-Pilone/dp/0596527357). In undergrad, I went to a much less prestigious school than Columbia, and I never had a course this boring, simple, and tedious. I was really in for a surprise. The redeeming feature of the course is that the teacher an the TAs (the one's we had) were all nice people. (not necessarily easy graders though!) The textbook is actually read from cover to cover and is actually affordable. However, you shouldn't take a course just because the textbook is cheap and the teacher is nice. I was initially attracted to this course because I thought I would spend most of the time coding a cool project. I ignored the negative reviews. I regret it. Don't make the same mistake.
I would not recommend this course unless a) you really want to be a software engineer and have no prior experience or b) absolutely need it to graduate. It's mostly busywork and stuff that you can learn in a decent summer internship at a software company (if you want to go into software). That being said, Gail is a wonderful person, and is very kind and understanding. However, her lectures tend to be very dry and not very helpful, and the course materials aren't any better. The course skims over component model frameworks, software testing and various software quality assurance techniques, but doesn't really go deep enough to make things useful. Most of these topics are covered briefly in lecture, and then exercised in a group project where they become a passing thought when completing your documentation. By the end, you'll learn that you should do 'xx' and 'yy' if you're working in the software industry on a big project, but will be unsure as to what exactly qualifies as 'xx' or 'yy'.
The lectures during the first half of the class were informative. The paper, project, and presentation were fun. This is a rare class in the CS program in that you can elect not to be in a group! Read that last sentence over again. I feel like way too much of my time has been wasted working with incompetent group members in other courses. The only downside to this course is that you are forced to sit through the other student's presentations. As in you get major points deducted if you skip even one day during student presentations. Many of your fellow students will not know how to give a presentation (dense text on slides, try to cover 40 slides in 10 minutes, mumble through the whole thing, etc). Many of them will also not speak English very well, some not at all. I kind of feel like it is somewhat sadistic to make a student that barely speaks English give a presentation... and make other people sit through it as well. Simple solution: bring a laptop and work on your project!
Professor Kaiser's lectures are generally quite well done. She uses lots and lots of powerpoint slides, which isn't generally my favorite approach -- I like it when lecturers use fewer slides, or just chalk and chalkboard if they can get away with it -- but she pulls it off pretty well. The class organization is quite strong, particularly with regard to the major assignments (paper and project, both of which include several milestones to meet aside from the final submission.) The work required and assignment specs were all laid out pretty clearly at the beginning of the semester, which was really refreshing, actually. Most of the other C.S. classes I've been in don't make specifications for assignments available until 1-3 weeks before they come due; it's hard to plan a semester that way. I'd say the course is intended to give a flavor of how web technology is used and how it developed -- up to and including the state of the art -- and it works well in that regard. A lot of information goes by quite fast, especially by the end, but students don't have to do all that much with lectures that don't relate to their project and paper, as there aren't exams.
Professor Kaiser is interested in her material and works hard at getting it across to her students. The only thing is that she isn't the best at instructing students how to code within the complex component frameworks introduced in this course. However, teams of students have freedom to choose a project of their liking, which is definitely preferred over a forced project such as Robot Wars or some ridiculous role playing game with clients, servers, and bots. With the freedom to choose a project comes the desire to code the project. Gail follows up with the teams throughout the semester, giving feedback and ensuring that the students pick up on the material, and I've been more enthusiastic about this class than I had been with others within the CompSci department. Don't be afraid of her first class when she tries to scare you off; you'll learn a lot, you'll learn how to document the software-development process, and if you work at your project, you'll walk out of the class knowing a great deal.