I rated this class "Very Hard" because if you didn't get to work in teams or have the professors essentially giving you all the homework answers, it would be impossible. This class is an embarrassment to the MCIT program. If you are interested in linear algebra you would be better served watching YouTube videos and taking an online class in probably any other medium. The professors write homework that are challenging but then essentially show you step by step how to do them in the OOH so everyone gets a good grade. The lectures are completely worthless as it is just the professors reading word for word from their PowerPoints - which are so terribly curated that there is a new page for every bullet point added on a slide. The concepts in this class really aren't all that complicated. But the professors find a way to overly complicate things with notation designed to confuse or by not being able to coherently explain the big picture. It is a real shame that this is the quality of class on this subject in this program as it is so important to Data Science. I would strongly discourage anyone from taking this class - even if you are really wanting to because of the subject. Save yourself the time and money and buy a Gilbert Strang book instead.

The lecture videos are equivalent(or even worse) to an audiobook of the textbook. Although the professors are really kind and trying to help, it would be better if they put effort into making the videos and the lecture structure more helpful. It would be 10times more fruitful and even easier to just watch some open course lectures on the internet if you are really interested in this topic. Recommend you to spend your 3300 dollar to another elective.

This course is very math notation heavy. The concept in the slides is very abstract. I feel like more concrete examples and more practice problems are needed in this course. However with that said, the course content is complete and the knowledge you learn here will be foundational for machine learning and artificial intelligence. The professor Jean and Jocelyn are both very friendly and helpful and will help you in your homework and programming project if you attend their office hours. The programming project also served as a good introduction to the syntax and coding in Matlab. The homework is very similar to 592 (a lot of proof based answer). So if you feel you are interested in mathematics, this elective is a good choice ! Personally I love this course and would recommend it

I did well in this course but cannot say I gained too much out of it. Prior to this course, I hadn't had much exposure to linear algebra, and my last calculus class was in over a decade ago in high school. The course felt like reading an acclaimed work of literature in a foriegn language with just bare minimum knowledge of that language - The professors are extremely kind and helpful, but the course was too notation heavy for me. Toward later weeks I became mired in deciphering notation I just picked up a week or too prior and quickly lost sight of the purpose of the applications of the approaches we were reviewing in this class. It was neat to get to try out Matlab and be able to understand how matrices play a part in common technical processes (e.g., visual search). However, I still get the feeling that I wasted one of my electives.

Great class if you like math. If you actually want to learn something and you don't have any previous background with the material, this class will be extremely hard. Given the target audience of this program, that will probably be many of the people that take this course. You should really spend some time exploring linear algebra and calculus before taking this course, if you aren't already familiar. This is set up more like a review of linear algebra, and less like a class to teach you from the ground up. There are very, very few worked examples and a lot of it is left up to you to figure out. There are homework assignments every week and 7 projects in the course. That means that some weeks you have multiple deliverables, which can be extremely stressful, especially if you are taking other classes/have other life commitments. Yes you can work in groups on the homework and projects, but that's not as amazing as it sounds unless someone else in your group falls into the "I've already studied linear algebra" camp. Despite the challenge, I have really enjoyed the course and the professors are extremely willing to help you with homework. As the other reviewer noted, it's not that hard to just get by in this class and get a solid grade. If you want to learn though, that is another story. I think it is really disingenuous to say that this class is easy, and reductive to say that taking it is a "no brainer".

I think the main problem with this course is that the material is presented in too abstract a way, and are basically copied out of the textbook. I ended up almost always looking at Youtube or other sources to understand the material. This would also be a lot of work to try doing by yourself - be sure to get a partner or two right away.

The content is clear and of high quality. But some guys may find it too math notation-heavy. It would be a pretty easy task if you had exposure to linear algebra before. You can work on assignments and projects in a group of 3. So a solid team member will do a great help. And the instructors offer enough help with assignments. The final is a bit more difficult than the weekly assignment, but the final is graded very leniently so that you would earn credits for writing what you know. Overall, it is not hard to get A. Maybe a good option to boost your GPA.

Interesting subject matter and reasonable workload for an elective. If you have a decent grasp of Python the first several assignments are fairly simple - mostly writing functions to perform different arithmetic operations and/or searches. TAs held recitations where they more or less went over the expected answer in Pseudocode and these were immensely helpful. The course does a great job of introducing you to a variety of concepts in traditional AI (A* Search, Minimax, etc.) and some of the more interesting concepts going on in Machine Learning (Reinforcement Learning, Neural Networks, Natural Language Processing). It was also good exposure to a variety of helpful Python libraries like NumPy, PyTorch, and several NLP libraries. There were also a ton of extra credit opportunities, but the course itself was weighted so that you could already have a very high grade from just doing the HW and weekly quizzes - unlimited submissions were allowed for both.

In my opinion, this class is terrible and should not even be offered in it's current form. The slides were pulled straight from a textbook that is extremely dense and notation heavy (without ever explaining the notation) and the lectures read straight off the slides. The professors wrote the textbook so they think it's easy to understand. I found that watching the lectures was not only useless, but it often made me more confused and frustrated than if I just googled the topics. This is supposed to be an introductory course with no pre-requisites besides calculus but it was far beyond that level and I feel that it could only be beneficial or enjoyable to someone studying pure mathematics. The professors are far too engulfed in the subject to the point where they have no idea how much lower their students' understanding is. When students asked questions on Piazza, myself included, they were often met with belittling responses from Professor Gallier saying things like "this is obvious" and "I already explained that" when the student is clearly asking the question because their prior explanation was too high-level to understand. I believe that the professors are very intelligent and perhaps they mean well (Professor Quaintance is very nice and has decent office hours), but I don't believe this class is effective at all. The only thing that made the class bearable was being able to work in groups, otherwise it would be much worse. If you wanted to actually understand all the material it would take over 30 hours a week. You can get by based on the design of the class with much less, but it will still be extremely frustrating and you won't learn much. If you love math and theory and have a linear algebra background, who knows, maybe you'll like it.

I get the impression that most people find this course very challenging. But honestly the hardest thing about it is really getting a sense of the mathematical notation used extensively throughout the course and the initial week learning Matlab. But that's really only because it's a math course. Outside of that, the concepts and projects are very easy and a lot of guidance is provided. If you run into difficulties, both profs and TAs have been very helpful in providing guidance in the right direction. Also with the way the deliverables are set up for Fall 2020, if you are on the ball and do well for every homework/project (you can work in groups of 3), since the final exam (which is OPEN BOOK) is 15%, you probably only need 70% and above in the final to get an A. Really a no brainer, would take this elective again.

The instructors are very nice and easily accessible, always willing to help. However, and maybe this is an unpopular opinion, I think they struggle with explaining concepts to students who aren't as familiar with linear algebra as they are. A lot of the time I'd see students asking for concepts to be explained on Piazza, only for the professors to repeat the same explanation that got the student confused in the first place. There seemed to be no attempt to recognize where (multiple) students are struggling and offer a different explanation for the concept. I and other students I spoke with had to look to outside resources for the majority of this course. Also, one of the hardest parts was deciphering what was critical to study. In the words of a past TA, only 1/4 of the course content is relevant to homeworks and exams. The way the course content is presented would probably require 30+ hrs a week to understand, and although I would love to have that time to study linear algebra, this course shouldn't require that. The professors teach it as though students are doing this course full time, with no effort to present the material in a more digestible way. They present it in a way that in order to understand one concept, you have to fully & completely understand every other concept they've ever taught. Maybe this makes sense to do, but I think some things should be taught using abstraction, so you can piece concepts together as you understand them, even if one presented earlier only really "clicks" for you later on. I know there are other students with different backgrounds who enjoyed it though, and I'm still thankful for the professors' help. If you have a strong background in linear algebra, you might enjoy taking this course and talking theory with the professors. If you have no or only some background - even if you prepare for this course like I did - you might regret taking it. I ended up with an A and have a decent understanding of the concepts now, but only because of outside resources and with plenty of avoidable frustration in the process.

A few years ago, I've seen a chief data scientist, presenting research based on a solution to an unsolvable optimization problem ( He was a Ph.D. and a visiting professor at a university ). This mistake can happen to anybody in the data science field including myself, so I was inclined to learn optimization. // The first half of the course covers important concepts of Linear Algebra. Mathematical notations/explanations can be frustrating if you are new to this subject or/and if English is not your first language like me. Sometimes, notations can be different from what you'd expect ( For instance, the uppercase "K" was not a matrix but a constant scalar ). However, you will eventually get used to those notations after finishing the first half. // In the second half, you finally get a chance to learn about optimization problems that are frequently solved in the industry, such as quadratic optimization problems. Homework and easy MatLab projects help you to review what you've learned by applying them to actual problems. // Overall, it's a great course. I also took CIS521 this semester, but it only gives you a basic outline of various types of AI models without teaching optimization. Hence, CIS515 will partially fill out that gap for those who want to design/train the model properly. But, for those who have never taken ( Linear Algebra, or Statistics ) nor have comparable experience ( e.g. Have done empirical research using dimensionality/noise reduction techniques. ), this course might be far more tricky than CIT596.

Interesting course! I generally liked the lectures. They give a broad overview. For future editions of the course, it would be great to slim down the "old" AI stuff such as BFS, DFS applications and focus more on contemporary applications of AI for instance cognitive cloud services. I was disappointed in the quality management of the course. Latex expressions not properly compiled in most of the HWs, errors in exam questions, errors in master solution of the exam, inflexible autograding.

Great curriculum and assignments that are relevant, fairly graded, and just the right amount of challenging. Assignments require a ton of Python. The class is admittedly more algorithm-based than statistical machine learning (there's only a couple weeks of reinforcement learning and neural nets), but still a fantastic course to take for aspiring DS or MLEs. I think the final grade reflects effort, as it is heavily based on homework, which you could reasonably get 90+ on all with effort.

This is a great class that allowed me to become comfortable with python and also laid out the fundamentals of machine learning algorithms. Each assignment was a thoughtfully crafted puzzle, and the TAs were very helpful when I got stuck. The first 1-3 weeks focused on getting a solid foundation i python, and afterwards the assignments were focused around translating algorithms into code.

My favorite elective course so far. I felt I have learned a lot and I especially enjoy the weekly assignments.

Professor Chris Callison-Burch is fantastic. He is charismatic, genuinely kind, and actively giving his all to improve each iteration of the course. When changes are made that are broadly unpopular he takes the student bodies concerns into account, and truly is trying to provide a high quality course. If you are new to Python the first couple of weeks can be very heavy. The weekly assignments vary in length and in complexity. In my experience with the course, the longest assignments took 20ish hours, the shortest took 3-4 hours. I would say the average was 8-10 hours total. The assignment are engaging and interesting and well worth the effort to complete.

What a fun class! This course was an approachable introduction to AI concepts and made me a much better Python programmer. The weekly assignments were put together well and (for the most part) pretty straightforward if you read the book/watched the lectures. I wish I had taken it with CCB only because he's so well reviewed and so engaging... but overall it was a still a positive experience. Assignments allowed for unlimited attempts to the autograder, and the tests were hard but only accounted for 20% of the overall grade... which made things very manageable. The concepts were tough but the class was definitely structured for student success. Overall I would recommend - particularly if you're looking to up your Python chops.

Not going to delve too deep (others have mentioned a lot of comprehensive reviews) BUT if you are interested in finding out how to solve the likes of Sudoku, Pacman, finding paths -- creating a mini Google Maps of your own with different levels of difficulty -- among others, and doing so the right way (!) this is the course for you. I found the variety of tasks that AIs can do to be fascinating! A pretty steep learning curve, but a lot of extra credits so that balances out. Super enjoyable, BUT don't sleep on the extra credit assignments until it is too late (which was what I did).

It is quite a lot of work both in terms of length of the recorded videos as well as coding homework especially if you’re not Python savvy. But contents are very well structured and fun like other reviews have mentioned, and staffs including professor CCB were super accessible. There were also a LOT of extra credit opportunities. Quizzes were unlimited attempt, homework was unlimited submission and usually ppl get 100. Two exams 10% each, mean at ~70. One double sided cheat sheet allowed but it really doesn’t help much.

For someone who has no prior CS experience before taking MCIT, expect a workload of 20 hrs for the first half of the semester. The second half of the semester will be relatively less challenging as you are more familiar with python. CCB is a very good lecturer and you should always watch the lectures instead of just reading the slides. If you are unlucky, you might find yourself trapped in some bugs for a long time. However, you never find the class boring as the homework topics are super interesting and the bugs you have never let you feel completely hopeless. TAs in this class are super helpful. Extra credits will be given and you should always take them because the final exam will drag your grades down. The course content covers a lot of 'old' topics. I doubt this class will give you the ability to talk about modern AI with your CS friends. Nevertheless, the class is well structured and interesting. It gives you just the right amount of challenge.

This has been the best elective I've taken so far. Heavy workload towards the beginning of the class but evened out after a few weeks. I liked the content quite a bit. Certainly a broad overview. The exams are a bit tough since they are based entirely of the textbook readings which can be long. Thankfully the exams aren't weighted very heavily. No final project either. Good class to take after 596.

This class was mainly effort based because the quizzes and HW were multi attempts. The two exams were only worth 10% each. This course was more math heavy than I thought it would be. You don’t have to understand all of the math to get a good grade in the course but to truly understand what is happenings requires math - which I thought the lectures did a poor job at explaining, especially towards the end. The assignments vary widely in how much time they take. There are 2 (maybe 3) HWs in a row in the middle of the course were the TAs practically give you the code and therefore the assignments take less than 5 hrs. Then there are others were the instructions are vague and you have to find a lot of information out in your own. Some of the assignments have timeouts, so getting the right answer isn’t enough, the code also has to be efficient. Overall a good class. It just barely touches the surface of AI. Definitely an intro course. My Python skills really increased and my data structure skills really got locked down

521 was a great class. CCB did an excellent job of balancing listening to student concerns with keeping a structured class. Considering the size of the fall semester class (570 students between online and on-campus!!), it was really well run. It's the only class where I felt like I just didn't have enough time to delve into everything I wanted to. Tons of extra credit, including EC assignments and participation in PhD projects. CCB has provided quite a bit of follow-up content for those wanting to continue on in their AI learning. I'm really happy I took this class.

One of my favorite courses in the program!

The learning curve for both python syntax and algorithm implementation was steep at the beginning of the course. Workload is steady; expect to write about 15 functions/week in this programming-heavy course. The prof is a GEM, he makes the course fun, he clearly has a passion for teaching that comes through in lectures and office hours. Although it was difficult for me, this was one of the MCITO courses I enjoyed the most.

Very nice course, give you a good understanding of data structures and software design.

This is a well-organized, quality course, but by no means an easy one. Python has a reputation as a relatively simple language, but the level required here goes well beyond nested for loops. If you're not already comfortable with, say, dictionary comprehension, OOP, and quickly getting up to speed with machine learning libraries, you'll have your work cut out for you. It's a programming-heavy class, with 10 assignments amounting to 70% of the overall grade. By contrast, the two midterms are noncumulative, open-note, and only count for 20% of the grade. These exams can still be quite difficult, though, since they go into the weeds of the course textbook and cite algorithms and concepts missing from the lectures. Bottom line: it's a class with either an assignment or a midterm due every week. For the sake of full disclosure, I wouldn't have minded a lighter course for my final semester, but I don't regret taking it either. The many positives include genuinely interesting material, fun and well-thought-out assignments, and an enthusiastic Professor. If you're really fluent in Python and looking to go into AI/ML professionally (or academically), this class is a no-brainer. If not, you should still enjoy and get a lot out of it, but be prepared for a more hectic pace and workload.

My favorite elective in this program. I'm glad I took it with CCB. He is expert in the field, yet his lectures were easy to understand. Not only did he find us opportunity to listen to seminars by different professors in AI world, he also offered lots of AI related research as extra credit. The homework was fun (for the first half of semester) and helped with my internship hunting since it covered some search algorithms and implementation. Exams were open note but since homework are 100% autograded, it's not hard to get an A if you put sometime into the homework. I enjoyed the course, and would recommend to anyone who's interested in practicing coding, learning introductory AI, or even just find a fun course.

Great class that I would recommend to anyone. It has some of the best and most engaging assignments in the whole program. Chris is a great instructor and a very nice person. The textbooks used were genuinely interesting. The only negative thing I can say is that the exams felt a little unfair, yet each one only counts 10% of your course grade. Most assignments are autograded and the last assignment teaches how to use GPT-3 which is an absolutely fascinating tool. If you are considering this elective, do not hesitate to take it!

This class would be a great follow up class if you enjoy 594 (algorithm part) and 596. The structure of the course grade is simply fair. Heavier weightage for weekly Gradescope assignments that allow for multiple attempts if you really want to strive for good grades (plus extra credits AI assignments to cover up for your 20% midterm+final short fall). Though the assignment instructions sometimes require a bit of deciphering to get the final 5-20% test cases to pass, you would save a lot of time to ask or check in Piazza if you have dabbled on the problem for more than 1-2 hours. I personally have completed few AI/ML/Computer Vision courses elsewhere, but this class really wants you to get your hands dirty to understand how the algorithm works with exams to really check if you grasp the concept behind each topics to just rather know how to apply ML on dataset/problems. This is the course when you finished, you have the confidence and the mastery to visualize the problems and going through the steps to build your agent/perceptron/NN/NLP to solve those problems.

I overall enjoyed this course - it is challenging and sometimes absurdly time-consuming, but full of interesting projects and I appreciated the grading scale that focused on homework assignments rather than exams (midterm and final were only weighted 10% each). I struggled a bit in the second half of the course as things got more mathematical, but still feel like I learned a lot and have a good foundation for going deeper into particular areas of AI. My biggest complaint is that some assignments only took 1-2 hours, while others took over 20, so it was hard to plan for in that sense. Would still recommend to anyone as a great elective!

This course is very easy for two reasons. First, the structure heavily weights auto-graded assignments: only 20% of the grade is exams. Getting an A+ on every assignment is straightforward. Second, the content is pretty shallow. It's a survey course, introducing you to a vast field of research. It would be impossible to go too deeply into any one topic. As a result, you can complete assignments without meaningfully understanding the material. Nonetheless, the course was interesting at times. In particular, it helped demystify neural networks for me, pulling back the curtain on LLMs. Understanding GPT is a real-life benefit for everyone, even if you're not working in machine learning or data science. I recommend taking this course directly after 596. Search algorithms and probability feature prominently. Having that material fresh in my head was helpful.

Overall a great class. Its tough in the beginning if you're not strong in Python. It will definitely level up your Python skills. The assignments range from very easy to pretty difficult. In particular, the Week 1 intro to python assignment is a doozy, and one of the hardest in the course IMHO. For the harder assignments, I would say a lot of the difficulty comes from subtle implementation details in Python, and not the concepts themselves. This is a very broad overview of the field of AI, and the instructor makes it really fun to learn. The lectures help you understand the material, and the textbook is a must read (and also a good read). Generally, if the professor asks you to read something in this class, do it. Good to pair with another class, but pace yourself in the beginning. The exams are low stress and fair (MC and short answer).

At the beginning of the semester, the class was a bit of a pain due to there not being enough office hours/ TAs. The professor was able to turn this around by scheduling more office hours at times that were convenient for everyone. It ended up being beneficial to not have as many office hours as a typical core class would have, because it really forced everyone to team up, communicate as a class and struggle with the material (in a positive way). I think it's worth taking, it gave me some exposure to C++ and llvm that I would not have experienced if I didn't take it.

Overall, I enjoyed this class, I am glad I took it, and I am glad it's over. IN GENERAL: I gained a working knowledge of Python and a basic understanding of search algorithms in AI and reinforcement learning. Much of the content was interesting to me because it built on concepts I learned earlier (search algorithms in 594/596). I liked the textbook: it's accessible and incorporates worked examples that make the content clear. I appreciate the professor's approach to grading: two exams are worth 10% each (the rest came from 10 HWs and weekly quizzes, which one could submit multiple times), and he was generous with extra credit. I found the content in last few weeks to be largely incomprehensible and didn't understand what I was doing in much of the last two assignments. TIME COMMITMENT: I am relatively new to programming, and Python was new to me when I began the class. So, the first three assignments took me 20-30+ hours each, and the last few took me 20+ hours each. Most other assignments didn't take nearly as long. For some of the earlier assignments, I started too early (before the HW recitations), which were helpful and would have saved some time, so I do recommend attending those.

This was an awesome class, and the most fun I've had in MCIT. The class provides a very good overview of AI, and Professor Callison-Burch is an excellent teacher. If you have a good grasp of Python, the workload will be moderate. If you're new to Python, you'll need to pick it up quickly and should treat this as a class with a heavy workload. Like most MCIT courses, the second half of the course tends to be more difficult, and there are a lot more math equations in the second half. While some of the algorithms discussed in the second half are ultimately based on linear algebra and multivariable calculus, the material is presented in a way that you'll be fine if you don't know/remember how to multiply a matrix or take a partial derivative. Finally, it's a good idea to start early on the final homework assignment, which will require getting up to speed on PyTorch--honestly, not starting early on that last homework is my biggest regret from this class.

Interesting material. Passionate and engaging professor. Assignments are fair and satisfying and most use an Autograder. Exams are tough but open note and only worth 10% each. Assignments are 70% altogether. Quizzes/Flash cards are the remaining 10% of grade. My semester, there were lots of Extra Credit opportunities.

I wanted so much to love this course, and though I marked it as Disliked I should clarify that there were portions I liked very much, and then portions that I really disliked. I agree with various other reviewers that the course spent a significant time on breadth with short segments on all the possible new technologies out there (it felt like every other lecture was talking about some other language or library). The first half of the course was very manageable and I really enjoyed learning pandas and SQL, but the homework assignments seemed to get more vague as the semester went on with frustrating troubleshooting to get the exact format the auto-grader wanted (I had to talk to three different TA's on one problem before finding out I needed to cast something to a data type that didn't make any sense for the question and wasn't in the instructions - even the last TA seemed irritated). Also, as someone else mentioned the final project on top of the final exam was very hectic, so plan accordingly if you plan on taking other courses. It was a heavy workload for me working full time with just the one course. The last thing I'll mention that I really disliked was the exams. The instructor only allows a single double-sided cheat sheet for an extremely large amount of data. If the questions were on overall concepts/ideas I wouldn't have minded, but there were a lot of super nitpicky questions about things that honestly no one would care about or would just look up at a job in the real world. As a person that switched in my role at work ~6 months ago to being a Data Scientist I don't have a ton of patience for being tested on nitpicky things that don't help me in my day to day job.

A lot of SQL and Python in course. Data analytics in first half then a lot of graphs, ml - supervised and unsupervised learning followed by neural networks Too many topics to get really deep into each one - it can become overwhelming Homeworks are spread around two weeks deadlines but, the autograder is very picky. You might need to go to office hours just to debug how the autograder is grading your code in Google collab The tas can be very picky about the labels and titles of graphs too. The homework is doable but, you do need to put in the time to do it. Some assignments are longer and harder than others. Depends on your background and skillsets on how fast you get through it. Specifically, the aws assignment takes a very long time to set up the console - almost 30 mins to 1 he to get start the homework assignment which made the whole assignment take more time. I think there was a cap of 4 hours to use the AWS console so that made it hard to take a break while doing the homework. Tas and professors are very nice and helpful The exams are very difficult and the cheat sheet is not so helpful when it's very specific theory answers. However, there was curve atleast for exam 1. End of course is very busy with a group project, homework and exam. Definitely plan out what type of team you are looking for vs. coursework vs. Potential work schedule. Some methods were a bit outdated compared to what I know from data science and analytics industry but, a good starting point. Overall, take the class if you want an intro to data analytics and enhance your SQL and Python skills.

Pros -Good introduction course to many analytics, big data, Spark, and machine learning topics. The course covers a lot of topics -HWs are every two weeks and spaced out well. Not too terrible to figure out. -Lots of sample notebooks and code provided to help with walkthroughs -Interesting topics if you like data science and analytics -topics flow logically through the course and lectures largely align with homeworks Cons -HW uses a finicky autograder that isn't always on point. Semi-dependent on TA help at times to figure out what the autograder is looking for -The course goes an inch deep into many many topics. You won't walk away with a deep understanding of anything but an intro to lots of different data science topics -some of the topics such as the deep learning weeks and unsupervised learning weeks get too 'mathy' for the speed at which this course is talk. The lectures will be quite theory and math heavy and not address enough of the practical coding side of thing (which is what you're graded on in HWs). -Some of the slides get confusing to follow.

My main qualm with this course is that it is misleadingly named and marketed. I went into it assuming we would study big data systems in depth, and apply them to data analytics tasks. This is NOT what this class is (CIS 5550 may be though - I didn't take it so I cannot comment). Instead, it is an introduction to data analytics class, where examples come from big data. I work as a data scientist. Hence, this class felt like a waste of time and money for me. The topics were too easy, without enough depth for a graduate course - it is unreasonable to expect to cover CNNs in half a module, time series in another half. On top of this, the assignments were made unnecessarily tricky by confusing instructions and an autograder that only considered some interpretations or made weird assumptions. Finally, the TA team was subpar compared to other MCIT classes, and I even felt that the instructor who was assigned to Piazza did not know some of the topics. On the positive side: if you are looking for a general intro to data analytics and its associated libraries, with barely any math, this is the class for you! The videos are overall clear and manage to cover a lot of ground in a short amount of time. The project is a great opportunity to dive deeper into a given area. At the end of this class you have the tools and frameworks to learn more. I wouldn't say this class is enough for you to become a data analyst/data scientist, but it does get you most of the way there; self-study/additional courses on the underlying mathematics and on experimentation would be a great supplement.

This class is laid out as follows: weekly lectures and unlimited-attempt quizzes, 5 hands-on homeworks (spaced two weeks apart), two non-cumulative midterms, and a group final project. The only part that I liked was the homeworks, although those had their own set of issues. You'll need to keep the long list of FAQs on one tab because the homework itself doesn't have enough instructions to know what they're asking for. It was almost comical the way the homework instructions would repeatedly admonish you to 'Start Early!!!" but the TA Recitation for that homework wouldn't be scheduled until 3-4 days before the HW due date. Despite those issues, I still enjoyed the HWs overall. This is the bread and butter of data science to me: manipulating Pandas dataframes, writing SQL queries, using Apache Spark, creating classifier and regression models. This is honestly the only part of the course where I felt like I was learning anything. The lectures: I found these lectures to be some of the worst in the entire MCIT program. They're long, rambling, and yet somehow don't convey any usable information. They're far too theoretical and they pretty much never show any actual examples of solving data science problems. I got to the point where I was skipping large portions of them because I couldn't retain any information being conveyed. The exams (which, thankfully, allow a cheat sheet) test you on a bunch of random minutae from the lectures that you'll probably never have any use for. I would have much preferred a timed proctored open book session of homework-style coding problems so that we could demonstrate that we know how to use the information from the course. The final project is so open ended so as to be kind of useless. You don't really learn anything new from it, you're pretty much just re-using code from the homeworks unless you're proactively out there looking for new techniques. I'd have preferred to just have a HW6 where you get to code something new. Overall: Wouldn't recommend.

This was BY FAR the most industry-relevant course I've taken in the program. It walks you through the essential steps of the data pipeline, from sourcing and wrangling data thru data prep and feature engineering, and finally training and tuning various models. The assignments provide excellent hands on experience with each step in the process, and uses libraries such as pandas, spark, sklearn, nltk, etc that are all immediately useful in industry. The professor also relates these concepts to cloud computing, which is a must-know in today's tech/job market. I wish all courses in MCIT were this practical.

Out of the 9 courses I have taken, this is by far my least favorite. There are many flaws to this course but I will just name two: 1. The course touches on way too many topics. Rather than deep diving into a particular area or code base, we seem to switch it up every few lectures. This does not allow the students ample time to thoroughly understand the concepts. This doesn't necessarily affect the ability to complete the homework (you will have to utilize various outside resources anyways), but it severely impacts how well you will do on the already tricky/nitpicky tests. 2. Homework: Each homework has consistent and troubling errors throughout. For most courses, FAQs and tips posted to Ed are simply tips to help you with your homework, not constantly calling out errors in the way the questions or assignment is written. In order to pass the autograder, you will need to study the FAQs to ensure you not only implement correct logically, but also implement to where it'll pass the broken test cases. This course could have been so much better by simply focusing on a few topics rather than try to touch on everything. The pandas and SQL portions were very informative and interesting, but then afterwards it went off the rails. I absolutely would recommend avoiding this course.

A broad overview of the data science pipeline from data wrangling to modeling. A ton of optional notebooks are provided to enhance skills and explore the topics covered each week. The homework is interesting but currently provides little feedback about what is wrong with a given input - this results in extra time "spinning wheels" when better problem descriptions or autograder feedback would save student time. In some cases, the course still felt like it was in "beta" mode with homework being updated after release. I enjoyed the course but am conflicted by it. I wish they focused more on the tools to achieve data analytics as a scale rather than a broad swathe of the data science pipeline. Upon completion, you are a jack of all trades, master of none.

This is a great course. The material is interesting, and thoughtfully constructed. The homework assignments allow for great depth of understanding, and often work through interesting datasets. Assessments are fair, and teaching staff accessible. Reinforces concepts learned in both 550 and 521, without be overly repetitious.

I think this is by far the most practical course I've ever had in MCIT. The lectures are long and boring. I learned most of the course materials by doing homework and checking API documents. Homeworks are due biweekly. It is totally manageable unless you start one day before the deadline. Yes, auto-graders can be annoying but I think the format, content, and difficulty are on point. Exams are tricky. The good thing about this course is that the average isn't crazy. If you do your work well you should be fine. As someone with 0 background in CS/stats, I think this is a must-take course. The workload is manageable. It covers lots of topics without getting too deep. You will get some practical skills after this class.

I took this course after taking 5410 (the practical ML course) and 5550, and this one was a crossover between the two with a bit of additional material sprinkled in. I though it was actually a perfect complement to the other two classes, strengthening my understanding of the materials while also giving some practical experience doing the same work in a distributed environment (5410 is exclusively local assignments). Additionally, the instruction of the material in this course is kind of rambly and not very effecitve in my opinion, so it was actually super helpful to have already touched a lot of the bases so I wasn't completely lost in the lectures. If you're taking the MSE-DS program, you're going to have to take these 3 classes no matter what, and I'd definitely recommend taking this course 3rd of the 3. The assignments aren't too difficult, but the later assignments do involve large data sets, distributed environments, and large models that take time to run, so keep that in mind since it's harder to try a bunch of things and iteratively get closer to the right answer, because it might take 10 minutes each time you want to test and answer. It pays to really understand the code you're writing first so you don't wait for your model to train for 20 minutes and then not get any points from the autograder. Exams were moderate, and even with a slightly below class average score on both, I ended up with an A- by getting full points on the assignments, so that can guide where to put your effort in the course if you're strapped for time.

I really hated this class. The number of homework assignments is low, but as a tradeoff, doing the homework mostly feels like stabbing around in the dark, and the lecture content is very long and rambly - this course has the most lecture material of any course I've taken in MCIT. I found it somewhat difficult to get help from course staff. My interest in the material was pretty low, so that's a factor, but I found the class downright dreadful.

As someone on a data scientist career path, this course was absolutely fundamental to my learning experience. Considerably more hands-on than CIS-550 (which I disliked, but is useful), and more focused than CIS-521 (my favorite course, but far more breadth than depth), CIS-545 is indispensable for anyone who wants to learn how to acquire, process, use, and derive value from big data. This involves learning about developing data pipelines, cloud infrastructure and high-level services for distributed systems, and statistical modeling (ML, deep learning, even some computer vision). I really enjoyed the course, the very applied and hands-on homework, and the final (collaborative) project. The exams were fair, and not very long. Highly recommended.

Overall, the course was a great beginner to intermediate level dive into the world of data analysis. Based on the previous reviews, I can understand how someone whose already into data science will find this an intro course. However, when I signed up for MCIT, the program was being advertised for those who are not professionals in IT field. The course covers topics that will set you up on the right track if you want to learn data analysis. It goes over pandas, sql, spark, mongodb (basic setup), aws (academic setup), and ML. It is designed in a way such that you learn by doing assignments. The HW are long and engaging with unlimited tries. A final project of your choice where you will implement everything you have learned in a group of 3-4. Major negatives: The feedback from autgrader is basically pass or fail. The lecture content though informative but can be long . Edstem responses are slow. I personally had no issues jumping into TA office hours but other people had some complains

The lecture covers an interesting range of topics and is probably a good (practical) introduction to data analysis (not necessarily "big", though), but unfortunately fails to provide a solid theoretical foundation. In my opinion, far too much time is spent on explanations on how to utilize certain frameworks or libraries and not enough on deriving the underlying concepts. In addition, on the rare occasions when some math is used, notation is inconsistent and explanations more hand-waving than thorough. Home works are mostly auto-graded with unlimited submissions, which is necessary since the assignments often fail to specify how the results should be formatted. Overall, probably a great course if you are interested in learning to apply standard tools and frameworks to real-world problems. Not so great if you would like to understand the theoretical basis upon which data science is built.

I have quite a bit of background in SQL from an application engineering and reporting perspective, so the first third of the course didn't feel particularly novel to me. But, nonetheless, I benefited from the exposure to pandas/dataframes and using python notebooks (Google Colab). It felt like only a couple weeks were spent on actual big data in the middle of the course, covering Apache Spark. The back half of the course covers supervised and unsupervised learning, which could have been a course by itself. I would have preferred that a course on big data would have spent more time covering how to actually work with big data rather than spending so much time on ML. The last few weeks of the course are intense - the last homework, a large group project, and the final exam is a lot, so keep that in mind when considering your course load. The rest of the course is easily managed. There are only 5 homeworks, usually with due dates 2-3 weeks out, which gives flexibility in your schedule. But be warned that they can take a lot of time to complete. I would guess I spent 8-14 hours on each assignment. So don't plan on completing them in a single evening after work (unless you already know the subject). Overall, I'm glad I took this course. It filled some holes for me in working with data, and gave me enough of a background in supervised and unsupervised learning that I could probably build some half-decent models and validate their accuracy/recall. But I really wanted more exposure to Apache Spark.

The course had one of the fewest homework in my experience at MCIT. In total, we only had 5 HWs, can be done ahead of time, and are submitted every two weeks. However, the learning curve between HWs is pretty steep: for a comparison, if I recall correctly in HW1 we are doing minor Python stuffs and web-scraping, but in HW2 we did a graph exploration using Spark, and so on until we did a lot of deep-learning stuffs in HW5. So, yes, for me who is relatively new to the field, that was quite a lot. However, preparing and tackling the assignments early helps a lot. There is a final project. Exams are mostly multiple choices in Gradescope, short answers at most. Also, in my experience, the final grades are curved. Overall, I liked the course, but for someone with experience, it might feel a little too light.

If you took 550, i will not recommend you take this course, because there is quite a bit of overlap in terms of SQL query stuff. Overview: the first half of the class was mostly just spark SQL query practice. so it wasn't difficult or interesting. the second half of the class superficially covered clustering techniques, time series analysis, neural networks, kafka streaming, etc. I don't think the course helped me develop any marketable skills given how little lecture time was given for each topic. There were only 5 assignments and they only focus on a few specific topics and don't really cover all of the lecture content, so what you learn from the assignments does not help strengthen your understanding of the lecture material. There was a final project at the end, but I don't think that project added much value to my learning experience given that the technical guidance that I got from TA was not very insightful. Positives: 1) Through this class I have learned that I will absolutely not want to be a data scientist/engineer. 2) The effort is low compare to other electives like 550 and 547. 3) I got some exposure to the kind of tasks that a data scientist would do, and having that perspective may help me with my job in the future. But seriously, I cannot recommend this course. It is not worth $3200.

This is very much a survey class of data science and data engineering rather than a deep dive into any specific topics. As long as you go in with that expectation you will get a lot out of this class. If you're looking to get an introduction to what data science is or already have a basic understanding but want to reinforce the concepts then you'll probably have a good experience. You'll finish the class with a good understanding of what data scientists do and will understand what terms like machine learning, neural networks, data wrangling, etc, all mean. If you already have a strong background, such as if you work in data analytics, and want to get a deep dive into more advanced topics then this probably isn't the best class for you. The lectures are quite long and rambly and the amount of video you'll need to watch is higher than most other classes. Professor Ives is good at breaking down topics but I feel that many of his videos could have been condensed into a few key points in a fraction of the time. I ended up watching most of them at 2x speed. But they still do a great job of introducing concepts and I learned a lot from them. Assignments are due only once every few weeks so this is a great class to take if you have a busy schedule. I never felt too rushed or pressed for time with the homework since you are given a while to complete it. Generally, you write some code and then an autograder will immediately tell you how many points you got on that section and you can rewrite it as many times as you'd like. It's a little frustrating sometimes because the grader won't provide any feedback, just will tell you how many points you got. So it can be a little challenging to figure out what went wrong. But otherwise, the homeworks are fair and provide a great opportunity to reinforce what you learned in class. You'll get quite comfortable writing SQL queries and will be fairly familiar with some of the libraries you can use for machine learning analysis. There is also a final project in the latter part of the class that's very open ended. You pretty much just have to pick a data set and some plan for analyzing it that will allow you to demonstrate what you learned in the class and can do almost anything with it. You should not expect to get much support from staff when taking this class. The TAs were pretty much MIA all semester and questions wouldn't get answered for a while on Ed Discussion. You should also expect to do most of the project on your own. We're supposed to have gotten feedback from TAs along the way but practically none was given. Office hours would also frequently get canceled without warning. So if you're someone who likes to interact with course staff and attend OH then keep in mind you may not be able to as much as you were in other classes. Although hopefully this will get better in future semesters.

This was the first course where I felt that I was in a master's program. Topics thought can be viewed as more niche but they are quite fundamental to computer science. Even if you don't end up working on compilers or analyzers it will give a good grasp of how parts of those things work. Assignments are challenging but the professor does a great job explaining it details the high-level logic of each assignment and gives partial pseudo-code that you can work with. Overall I think the professor is the one who makes this course 10/10. But be ready to struggle at the beginning of each assignment and get up to speed with C++ quickly.

Software analysis skills are vital for software engineers. You will learn about the different methods currently used for automated software analysis, what they can be used for, what are their limitations. You will also learn about the tools available on the market (You met one of them -Valgrind- at CIT-593) and you will try your hand at writing your own analyzers as well. The lectures are easy to follow and understand, but working with LLVM caused quite a lot of struggle, due to its minimalistic documentation. The course staff reacted to this problem, however, and compiled a good tutorial for the next iterations of the course. You will need C++, which is not C, this is why I strongly advise you to study C++ before the course; else the first weeks can be pretty hard.

This course is a good foundation for those who are planning to learn compilers in the future.

I don't have too much to add to the earlier reviews, which I found to be very accurate, both in terms of pros and cons. The material and assignments can be quite challenging, but the Professor is a super nice guy who continuously strives to improve the course and students' experience. Untangling LLVM IR is part of the process, but I highly recommend learning the basics of C++ ahead of time; if you can explain how iterators work and loop through the contents of sets and vectors, you'll be in great shape. Beyond that, just be sure to stay on schedule, attend office hours, and work with other students to understand the concepts and what the instructions ask of you (the Professor encourages reasonable collaboration). The final exam is open-note and comparable in difficulty to 595. There are a few kinks left to work out—one assignment in particular took us all of October—but overall this is a good model of how an MCITO elective should be.

I took this class because of the previous positive reviews and because I wanted to learn C++. Ultimately, I very, very, very much regret taking this class. I thought it was an absolutely gigantic waste of time and am near positive I will not use 95% of the course material ever again. First, while most homework is in C++, it is almost entirely using LLVM, which is a really annoying and poorly documented codebase to use. Despite getting perfect scores on most assignments, I do not think I could professionally use C++ or market it as a skill since I touched only a very small portion of C++. Secondly, I do not think the material is useful/marketable for most software engineering roles. During this course, I began my first role as a software engineer at a large tech company, and none of the senior engineers have ever come across the material presented in their professional lives, which gives me pause as to whether I ever will. If you had specific interest in testing, then I could see it being useful, but the parts useful for majority of engineering roles could probably be accomplished in a week or 2. While this is a matter of opinion, I found the lecture videos to be unbelievably dry and boring, like watching paint dry. It is clear the professor is an expert on the subject, and the videos aren't necessarily bad quality, but I found them incredibly unpleasant to watch. Additionally, there is a large disconnect between the lecture and the homework. You could reasonably complete all homework assignments without paying much attention to any lecture. I found this to be somewhat frustrating since it was unclear which part was actually important. And lastly, I thought how homework releases and support worked were very frustrating. For the assignments due later in the semester, the directions became borderline unintelligible. You pretty much had to sit through the 2 hour recitation in order to understand what is actually being asked of you. In an asynchronous program, I would prefer that the assignment directions give enough info for someone to be successful on their own. Secondly, it was annoying to have grading switch from autograding to normal submissions for the last 2 assignments. It felt like the professor/TAs just did not have the autograding in place on time, which was a letdown. Also, I found the TA responses to be generally sufficient but much slower response times compared to other classes I took, which was not great on assignments with 1 week turnarounds. Maybe it is my fault for taking this class, but I had a truly awful experience and wish I had a time machine to tell myself not to take it. I would encourage anyone considering it to dig into LLVM and the topic and decide for themselves whether they actually care about the material, and not just go off the good reviews.

- Course provides significant exposure to C++ through the LLVM compiler API. Great class for learning more about compilers and code testing techniques. Cornerstone for a career in software development/engineering. The class is graded very fairly. Unlimited attempts with an autograder are provided for each assignment. TAs are very helpful. Recitation is held once weekly + open office hours. Professor is highly engaged. Assignments are challenging, but with determined effort + carefully going through lectures, can be tackled in a moderate amount of time. Lectures are very helpful and well-put together.

A good course to learn how to program with object-oriented language especially Java. The homework and exam have fair difficulty. However, if you want to learn more and truly want to handle that, I would recommend you to finish all the projects by yourself, even those that will not be graded.

Amazing course, professor puts a lot of time and effort to constantly improve it and is highly engaged with students. He is an researcher in the field, so if you ask he will give lots of examples, supplemental material and advice. You get to learn a lot of different software analysis tools (think about valgrind) understanding the underlying theory behind them, which by the nature of the topic knowing such theory is crucial to effectively apply the tools in real life settings. Theory can be abstract at times and requires careful understanding of terms, algorithms, and big picture. Professor says he constantly changes the labs (hw assignments) trying to make them more fun for students so likely will change in further offerings. In our semester labs were really cool making C++ programs to analyze other C programs (e.g. divide by zero errors, segfaults, etc.), which were really cool (albeit time consuming) projects, you get to write programs that will intercept real world compiler to analyze programs. Besides software analysis per se we learned C++, LLVM, and Z3. There are 9 labs probably 5 of them would be highly marketable on resumes. In a way this course feels as a continuation of 593 + 596, if you liked them you will enjoy.

Excellent course, I learned so much and I am glad I took CIS 547 as an elective. Professor Naik is very nice and helpful (it was not uncommon to see him directly respond to Piazza questions each week) and his lecture videos are clear, organized, and polished. He actually has all of the videos he uses posted publicly on Youtube (just search for Mayur Naik) so if you are interested in the course you can check out his videos to learn more about what the material entails. Homework is a coding project due weekly or sometimes biweekly and several weekly small quizzes, which you get a couple attempts each. All assignments are in C++, some more challenging/time-consuming (e.g. lab 4/5, lab 9) than others. I had zero experience with C++ so the first few projects took a lot longer than they probably should have, so like others have said, reviewing C++ may be helpful to prepare for this course. LLVM IR was also very frustrating and confusing to understand but luckily the TAs and professor were there for me when I felt stuck.

The assignments in this course are still works-in-progress, as it has not been run very many times for the program; however, the professor is extremely supportive and willing to provide additional resources so this made up for any rough patches in the course design. The material is interesting and focuses on what automated tools can be used to find bugs in software, including industry standards, and feels very current. If you are confident in programming C and Java then learning C++ is not a significant obstacle as it combines C syntax with principles of object oriented programming. Some of the lectures are dense but overall I found the topic very interesting. The most interesting and useful skill I learned in this course is how to instrument LLVM intermediate representation; this means using the LLVM compiler (popular with several large software companies you've heard of) to create an "intermediate representation" of code in between a language like C and an assembly language. You then "instrument" this intermediate code by automatically injecting extra code which can help you to better understand the functionality of the program. For example, you can figure out which branches of your code may be associated with bugs. These projects feel very practical. One downside to learning these interesting techniques of working with the LLVM compiler is that the API for LLVM is extremely dense. It is also difficult to find easy-to-apply examples on StackOverflow and other online resources. A study group can be very helpful to crowdsource how to work with LLVM given the limited information available. This is not a fault of the course necessarily but can be a frustrating byproduct of learning something that feels so new and useable. If you liked working with assembly in 593, you may enjoy this course! But, if you hated it, you may still enjoy it - all labs are written in C or C++ using LLVM API.

This course has a really dedicated and knowledgeable professor. The recitations were the cornerstone of the class. The material is relevant and increasingly important and ultimately I think this course will help me be a better programmer going forward.

Overall I recommend this class for students who are interested in learning more about compilers, testing, or C++ coding. I doubt that the course will be directly useful to most software engineers or test/QA engineers beyond introducing some testing strategies and advanced testing libraries that engineers might use, but it provides a lot of hands-on C++ coding experience and usage of the LLVM compiler API. The course isn't as detailed as an actual compilers elective, but in its absence it's a good elective for people who want to do more low-level coding. The lecture material can be a bit dry; on the other hand, the professor is really great and his open office hours/recitations are a joy to watch. Projects are a big jump up from lecture content and the project recitations are essentially mandatory in order to get the projects done.There is only one final exam and it is open note, and generally it was fair and similar to the provided practice exam. This summer the TA and professor support was lacking and it was difficult to receive personalized help on either private office hours and Piazza. Due to the TA shortage the professor switched his OOH to private office hours midway through the semester which was a huge loss in terms of learning opportunities.

Excellent course if you want to learn about how to test and analyze software (i.e. become a software engineer). It touches on what software analysis programs major companies use and is thoroughly interesting. The homework assignments are some of the best in MCIT and you gain an in-depth understanding of why companies ask you to send them bug reports (when your program crashes). I recommend if you want to become a software engineer.

For my taste, this course is too focused on a few aspects. After completing it, you probably have a good understanding of how to detect division by zero errors in your code. I missed a bigger picture though in course though. What about efficiency analysis or other types of errors? I could finish the assignments at the beginning by myself, after the middle of the course only with support of the TAs. Rather than fully understanding what was going on, I was too often just tweaking my code in order to get full points (i.e. could have been any content). Also, the assignments cost me too many long- or all-nighters.

The course will be easy if you know the concepts already. But can be tricky for the novice since the lectures didn't explain the concept very well.

Useful statistical and graph theory course. The content would be super helpful to your career if you work in the data industry. Def not an easy course. Tips: Do practice questions + search Youtube Videoes if you feel not clear about some topics.

Overall, I enjoyed this class very much and learned a lot. It is, however, somewhat different from the other classes in the program. As the other reviews mention, there is a lot of technical material and many acronyms to remember. There were weeks when I had to go through the lecture material several times. However, the important concepts come up multiple times and while it might seem a bit overwhelming at first, things fall into place over time. The course had a mid-term research paper instead of an exam. It was interesting to have a different type of assignment but I did find it challenging to write the paper and for me this was one of the harder assignments. The course also had a final, which I felt was a fair exam. There are quizzes which I found to be more challenging than those from other classes. There are several projects and a couple of homework assignments. For most of the projects, you work with a partner. The projects were overall straightforward and not too difficult. The exception is the last group project which was quite challenging and required a higher than average amount of time during the week. With the exception of the last group project, there is not a lot of coding required, most of the project is the analysis of your results. The projects are done in C++, but a basic understanding of C will get you though 99% of the coding. Professor Kim is very active on Piazza and most of my questions were answered very quickly. He does about 10 recitation sessions where he covers the key material from the previous week or two and this is a great time to ask questions. I highly recommend attending these session and the office hours. He is more than willing to explain the material, multiple times if needed. I appreciated his knowledge in the subject and his willingness to help his students. I really enjoyed this class and I highly recommend it to anyone who has an interest in this material.

This is an excellent follow on elective for anyone who really enjoyed 593 and 595. The work gets very technical and there are a lot of new acronyms to learn. Unless you are coming from an electrical engineering background, there will be a lot of new material and new terms, especially once you get to the LTE topics and beyond. The projects are done in C and C++ and can be time consuming but most are done in teams. There is also an emphasis on writing in this course, including a midterm research paper, which seems to be unique in the program.

The general structure of the course remains unchanged for this semester. Professor Kim is still a very ardent teacher who offers a lot of time in office hours and recitations. One point to note is that only the last project is done with another teammate. The other projects are done individually in this semester. The topics of the course cover various common physical and system architecture layers of the various networks, including WiFi, 4G LTE, 5G NR, and LoRa. Other relevant networking knowledge are also introduced in appropriate context. As opposed to what normal software engineers would concern, these underlying layers are often hidden from our point of view and we would mostly treat the physical transmission of signals as "black magic" that just so happens to work. However, throughout this course we would notice that these network characteristics and capabilities are essential to make good application design and technology choices, in particular for students who are concerned with IoT and mobile application development. It would be a shame if this course will not be offered in the future semesters.

This is a great class to take if you are interested in networks and want to learn more about the wireless domain or IoT. To get the most out of it, I would recommend either taking it after or alongside 553 Networked Systems. There is some amount of overlap as 549 is designed to review some of the core concepts from 553 (TCP/IP/CSMA) in the first few weeks, but it quickly diverges to focus on wireless technologies. Even the review portion itself I didn't mind since it was coming from a different perspective. Also, although this is not an EE class, there is more material related to the link and physical layer compared to 553. The class itself is challenging and the material is very dense, but after all is said and done I feel like I have a good grasp of how wireless systems work. The workload can be pretty heavy at times, especially if like me, you haven't written many research papers. Most of the projects don't require much code, but the last group project is conceptually very challenging. Professor Kim is a gem and due to the small class size he is always quick to respond and hop on a one-on-one session. Even if you don't spend much time working with mobile networks or IoT after this course, wireless technologies are ubiquitous and understanding that paradigm will no doubt be useful if you're working with networks at any level.

The topics are interesting. The professor is very dedicated to teaching and would hop on a Zoom call with individual students within 10 minutes of a Piazza post. The only reason I selected 'dislike' is that the course material is too memorization heavy for my taste... I seriously don't think I'd remember much of the technical jargon and inner workings of 4G LTE the week after final exam.

This one became my favorite course. It is dense and some topics, if you want to go deeper into them, are rabbit holes really but I have learned a lot. The course creates a perfect base for continuing development in the mobile networks domain either in the lower layers fields or software. Professor Kim is really great and as there's not many students in the course everyone can actually have 1-on-1 session with the Professor if one struggles with some topic. In my view, the course offers rare journey to the phy and mac layers and makes you understand how things really work. And - look up for acronyms, eventually they will sink inside, but when I have started to face them and listen/read some additional materials I was done, but on final I recognized them all at a glance. Enjoyed the course and wish it were for 2 semesters rather than one. There are also self-paced (optional) projects and demos that show how to create your own container, how to set up real IoT device and how to emulate the real LTE system (eNB and UE) physically! I started to speak the same language with my portfolio companies on my main job after that course (they work in the network/mobile/RF/IoT fields) so really appreciate it!

Took the class because of the low workload. Wasn't all that interested in the material going into the class and left the class even less interested in the technology. Pros: -Light workload Cons: -one attempt quizzes that make up a large chunk of the grade -a tough final project that could really use better instructions and debugging tools (really most of the assignments were quite lacking in this department) -boring lectures about boring material You probably won't learn anything useful in this class, but if you need a to take a light semester or add a filler class its not a bad option.

This was the most difficult course that I've taken, but it was also my favorite. It is incredibly well structured and the professor is the best MCIT professor that I've had. Professor Kim is always available, and since enrollment is low, his students get the VIP treatment. The difficulty comes from the sheer amount of knowledge that you have to internalize. Think 593, but a bit more volume and a bit harder projects. The projects are decently straightforward, though. The project outline documents/helper videos are very well-made and thorough. Look out for the 4th project. It's more complex than the others. Luckily Project 5 is fun and very hard to mess-up or do poorly on--a respite as you review the massive amount of material needed for the final exam. Oh yeah, the projects are done with a partner, thankfully. The midterm is a literature review style research paper--it's less horrible than it sounds. Pacing is great in the course, leaving extra room for tackling the paper and 4th project. Still... DO NOT PROCRASTINATE ON EITHER. Trust me. Like 593, the zombies will catch up to you in this course if you stop moving. If you go steadily, it isn't bad at all. Regardless, you learn extremely fascinating topics from an industry guru. Enrollment in this course is usually pretty low. Many in the program want to be FAANG software engineers, but if you take this class seriously you can be a shoo-in for more niche ISP/network operator jobs. Big $$$. I've seen several job posting that request LTE/5G infrastructure knowledge and NS3 simulator experience that would be a perfect fit for a 549 alum. I think it deserves more consideration as IoT and mobile networks are becoming ever more important.

This course has an intense workload, although you learn a lot as a result. The lectures pack a ton of material in, the quizzes are the most difficult in any course (but you do get 2 attempts), and the projects are a lot of work (but fortunately most of them you do with a partner that is the same throughout the semester). Professor Kim knows the material well and really wants every student to succeed, so he often responds to Piazza posts in less than 15 minutes and makes himself readily available via Zoom to whoever needs help. The course starts with TCP/IP, ethernet & Wi-Fi, then moves to the history of cellular communications from 1G to 5G, as well as IoT. The reason I did not give this a "really liked" rating is I wish there was more time dedicated to 5G (5G is the last 2 weeks of lectures) and less time for IoT (which is 3.5 weeks of the lectures). The midterm is a research paper which is peer graded, and there is only 1 exam (the final) which is similar to the quizzes and homework assignments.

This is an excellent course that thoroughly covers how wireless networks and the Internet of Things work. There is an immense amount of technical information to absorb, and sometimes it's easy to get overwhelmed by the dozens upon dozens of acronyms. Fortunately, Professor Kim is extremely accessible and dedicated to making sure that you understand the material. This is a challenging course--on par with, say, 593--and the workload is heavy. However, you are paired with a partner for most of the projects, and if you put in the effort, you will do well.

This course is both great, and extremely frustrating. Some weeks the lecture material is well put together and practical, while others overly dense and abstract. In the case of the latter the professor seems to speed run the topics while reading off their prepared script. With careful viewing and reviewing this can be overcome. The group project is the cornerstone of this course. I found it to be a fantastic learning opportunity, however this can also be a nightmare with the wrong group members. All in all this course has vital content for anyone who wants to journey into the world of software engineering, but needs to be navigated carefully.

This course offers must-have skills for a software engineer. Understanding how databases work and building web applications. The challenging part of the course is, besides learning databases theories and SQL, you need to spend extra time picking up a few programming language or framework on the side. E.g. you need to learn React.JS and node.JS for the final group project, also need to pick up python/pandas to do data cleaning and preprocessing. I took this course with a little knowledge of python and javascript, and still spent a lot of time picking up those skills and doing the group project. However, it is a very rewarding experience as now that I have a decent project on my resume that I am comfortable talking about any technical details.

Big disappointment with this course. Many reviews will state that this course is a must-take if you hope to get a job in web development, but alas this is probably the least informative course on offer in the whole program. Very high level introduction to SQL (the 'advanced sql' week is basically just table joining, which is about as basic sql as you can get imo), a single week touching on modern NoSQL tool like MongoDB (document based db) and Neo4j (graph-based db) which is great but barely gets you past a simple select query, and a surface level overview of javascript that aims to get you just familiar enough that you can copy paste some code from the second assignment into your final project to make a UI in case you've never done web development before. Things that are missing from this course: real advanced sql like window functions and sql functions that are specific to different engines (like postgres vs. oracle vs mysql). Deeper dive into NoSQL (they mention that they're very rapidly becoming the most popular db management systems, yet get less than an hour of content). Real web development chops to connect your db to something useful (doing more than just displaying a static table of results – how about interacting with your data, caching it, preventing sql injection attacks, when to work with data server-side vs client side, managing state in react applications, etc). I get that there's only so much time in a semester, and that in a course focused on databases they should rightly avoid going into all the million things you could learn about web development. But here's the kicker – I came into this course knowing 0 sql, basic javascript (from a codecademy intro), having never built a website or done web development outside of squarespace, and yet I was able to learn all the things I mentioned were missing in this course via youtube and stackexchange and reading the plethora of actually fantastic documentation out there. You could easily condense the first 7 weeks of the course into 2 and spend a good deal more time on NoSQL and maybe even an extra week updating the outdated javascript week to include modern technologies (or at least a version of node that isn't in the 'end-of-life'). I'd be upset about wasting one of my 4 precious electives on this course if it weren't for the fact that it's a requirement for the dual-degree program. If you've got to take it anyway, it's not a terrible course, just a bit outdated and definitely not worth the money spent or taking up a spot you could use to learn something worthy of a Penn graduate level course.

Must-have for SW engineering - this course teaches SQL and web dev. I started off very enthusiastic and lost steam partway through, mainly because most of the lectures are focused on database concepts, which can be dry. The lecture quality wasn't fantastic, but not bad either. However, the assignments involve practical coding in SQL, MongoDB, and Neo4j, which are useful in just about any engineering role (SQL in particular). The group project was the highlight, mainly because my team worked well together and we worked on a project that "mattered" to each of us. The assignments can be time-consuming and the final project required lots of self-study and googling. All in all, I strongly recommend this course in spite of some of its pitfalls/challenges.

This is definitely the most intense course in MCIT that I've personally taken, but it has also been the most useful course I could have ever taken as someone who came in with 0 experience in web development, SQL and statistics / data / discrete math. I've come out of this course as a full-stack developer. I had wanted to take a bootcamp before this so that I could learn more "practical software engineering", but this course has brought me further than I expected and I'm now confident to build my own side projects and apps. However, it comes with a strong caveat that I spent almost all my time aside from my day job on this course (around ~30 hours a week, unlike other courses where I averaged around only 8-10 hours a week). Relating to databases, I found the course materials to be very well designed (except the last large part of query optimization which was so, so bad). The tutorials were quite intense and usually have many questions and go deeper than the lecture material (every one of them had so many questions and ensured you thoroughly understood and explored the material through practice.) As someone with 0 SQL / MongoDB or even just db experience, I actually felt that I became so familiar with SQL at the end of the first 2 weeks by doing that ridiculously long tutorial and only sitting through the first 2 weeks of crash course on SQL. They also ensured that you know how to set up a Oracle / MySQL database which was super useful and practical. I also became very familiar with NoSQL databases like MongoDB and a graph database like Neo4j, which is a good spread on the database types I can now tap on for my side projects. Although many of the reviews said that this course was "mostly database theory", I actually felt that the "theory" learnt was very relevant and useful in the practical sense. Besides just learning about database theory, the group project actually gave us a lot of opportunities to apply those theory directly in practice. My group implemented database design, normalization, indexing, query optimization and transactions, etc., by applying the "theory" taught in class which was so much harder to learn by yourself as compared to the implementation where we just had to google the appropriate syntax to achieve the "theory". These "theories" were what made our database design elegant and our queries fast, as compared to simply setting up a database with no theory. However, one thing to note is that the last part on query optimization (lectures 8-9, 12-13) were really bad. The lectures do not cover the required learning objectives well at all even though I rewatched them countless of times. You are probably expected to read the textbook by yourself to learn more, which is a huge time commitment on top of the intense HWs, group project, etc. I ended up reading almost every required chapter which was around ~50 pages? Relating to web development, I was super afraid coming into this course as almost all the reviews had mentioned that you would have to learn React on your own. Indeed, in week 3, they spent 1 hour each on HTML + CSS + JavaScript, React and Node.js, then expected you to work on a HW2 that was extremely guided. However, the group project required you to build a web app, which heavily relied on your web development skill (although you could get by with team mates who were already strong in it and if you just did the database part). To maximize what I got out of this course, I had bravely offered to work on the entire frontend of the group project, hoping to ride on the grades pressure to force myself to master web development once and for all. I spent the first few weeks reading docs and grinding javascript practice, followed by developing some small projects on react and node.js on my own. All these were actually manageable in the first few weeks and paid off as I ended up developing a very huge portion of our group project, which ended up as one of the awarded projects. Something I would probably recommend is to split your architecture into 3 layer and have each person work on it in parallel after the requirements and api specs are out. This helped our team to be way ahead of all the milestones and I managed to complete the front end 1.5 months ahead of the final deadline. However, we could have started earlier on the query optimization which ended up eating into the last 2 weeks of final exams studying (and was arguably the most challenging / unpredictable part of the project). As a result, we pulled through 1 crazy final week to complete the query optimization, report, video demo and final presentation, all in 1 within 5 days after the final midterms. All in all, I would definitely recommend this course to someone who is very keen to learn practical software engineering and can afford the time to do so. However, if you are looking to take a relaxing course or to get your As without significant effort, avoid this course at all costs. The grading criteria for this course is very well spread out (50% on "theory" midterms, 25% on group project and 25% on 6 intense biweekly homeworks), every graded item has a significant difficulty to it, and there is NO CURVE, hence it would very difficult to do well unless you put in a huge time commitment to ensure every graded part was well executed. The median grade for the first midterm was around 75%, which already set most people back from the grade A by quite a lot.

I am not much better in databases than I was at the beginning of this course. Most of the course is incredibly dry theory. Much of it is not, or not enough, tied back into practice. Hands-on, there is a total of one or two weeks of SQL and one week of NoSQL. Everything else is either theory or web dev. For example, the final two weeks are query optimization, a very important topic, but not at all taught in a way in which you will be better at applying these concepts whatsoever. Overall, this is the most boring, "missed opportunity," course I have taken so far in the program. Honestly, as an SWE that does a lot of work with databases, I will probably end up taking a MOOC in DBMS, this class just has not really done much for me.

This class was so frustrating that I’ve had to write down my grips with the class throughout the semester as a form of therapy. This is the result. See the last paragraph for some positives about the course. My issues with this class can be broadly broken into the following: material is lazy, bad TAs, and in general the course feels like it’s out to get you. Material is Lazy Almost all of the lectures were recorded in 2019, which is more than three years ago as of this writing. This wouldn’t be a problem if the lectures were actually good. The videos don’t have enough explanation, it’s just the professor’s voiceover reading each word of the slide out loud. The slides read like condensed gibberish. The steps in logic are often not explained, leaving listeners confused about how one thing leads to another. There are way too many “self paced exercises” where material is typed up in a PDF for the students to learn by themselves. The issue is, these are often the more difficult parts of the material that would really benefit from someone walking through it. Instead we’re left to our own devices to decipher these exercises. Now this wouldn’t be a problem if there was a good TA support network, which leads me to the second thing. Bad TAs To the TAs’ credit, they do respond to questions on Ed Discussion in a timely manner. Some of the TAs very clearly make an effort to help and are very nice. But the positives stop there. Sometimes we receive a completely unnecessary condescending comment from a TA. I would like to remind TAs that the material should seem easy to you because you are a TA. The rest of us are literally here to learn said material. You’re supposed to help us do that, and being patronizing is not helping. Second, TAs are also responsible for recitations, where they walk through some example problems using class material. This can be heavily hit or miss depending on the TA. I once had a TA during recitation copy an answer from somewhere else to explain a problem to us. When asked how they got to that answer, they literally said they did not know. Third, the TAs are awful at grading. I’m sure every student had a few grading mistakes that required regrades. With almost 300 students, 14 assignments, and 3 exams, that’s way too many grading mistakes. There are a few times where even if your answers and explanations are correct, you will be marked fully wrong if your write up does not match the exact specification. The rubric could explicitly tell TAs to accept various correct answers and TAs would still take away points if it does not match exactly to the solution they were given. I once had a grader give a counterexample to why my solution was wrong, without even checking that my solution covered their counterexample completely. Even though grading mistakes are almost always corrected upon regrade request, it is still incredibly frustrating. This happens so often that it’s hard to believe these are genuine mistakes. It really comes off as contempt for the student or TA incompetence. Course Wants You to Fail This course seems to be doing everything possible to trick you. The problems are intentionally worded poorly and TAs are told to resist any clarification. We’re constantly asked to write solutions to HW problems in a specific way, but are often not taught how to from the course material. For example, we’re often asked to write solutions in a closed form format, but we were never officially told what closed form format means. Looking up “closed form” online gives us different definitions than what is used in class. Eventually we’re expected to submit answers in closed form even without prompting from the problem. We then get docked points for not doing so even though that requirement wasn’t in the problem. In the probability unit, we were told to define a probability space for every solution but were not told how to do so from lectures. The TAs got so many questions regarding this they eventually wrote up a huge guide on Ed Discussion. This guide should have existed already without students asking for it. If the class is looking for a specific way of writing a solution, we have to be told how to write it! It’s not like the class doesn’t know this. During the induction section of the course, the professor walks through clearly how to write an induction proof in lectures. But for some reason for every other topic they fail to outline in lectures how solutions should be written. The course is intent on shoving as much math notation down our throats as possible. When something can be easily explained using plain language, the course material prefers to have everything in math notation. I remember a TA saying they “don’t understand why students have so much trouble with notation.” I’ll tell you why. It’s because we’re not mathematicians. We navigate everyday life with language that is perfectly capable of describing the concepts you’re trying to teach. We’ve had very little experience looking at math notation, how can we be expected to be able to read it accurately and easily. Math notation would be a lot easier to learn if we had a sentence in plain language that translates long chains of notation. But that would be too much work for the lazy course material. This class requires a ton of work outside of actual learning because students have to constantly double, triple, and quadruple check answers to make sure the way they’re written fits neatly into draconian grading standards. I think I speak for a lot of students when I say that we actually appreciate a difficult class (see reviews on CIT 593), but this class simply did not give us the tools to succeed and actively tried to make us fail. We have to spend more time looking for supplementary learning material online. If we learn how to solve a problem from other sources, we have to hope that the answers we write based on outside learning will be graded fairly by TAs and accepted as correct. More work in this class in no way means more learning, it actually detracts from our appreciation of the material. Compare this course to CIT 593 - Computer Systems. CIT 593 is known to be a lot of work, but the work serves to reinforce our learning. I would strongly recommend students not take this class and CIT 593 together because that will highlight just how bad this class is and heap on more frustration. Positives It’s a shame because the material in the course really is interesting. The problems are all interesting little puzzles and I feel like we’re building up a toolbox to find real solutions. Professor Tannen is extremely helpful in office hours. I often think if they just took clips from his office hours and edited it down into additional course material, this class would improve manyfold. He tries to sprinkle humor into the material and problems which does help take the stress off a little. This course can really benefit from a revamp of the teaching material and from hiring TAs who are thoughtful, good communicators, and actually interested in helping others learn.

This course is currently one of the only courses in our curriculum that allows an open-ended group project in the form of a web app. For those hoping to add one of these projects to their resume, as well as dip their toes into backend and frontend work, this is a good course. For others, the course is still a good one to learn the basics of database theory, but it may be annoying to spend more time on front-end and non-database work if you are primarily/exclusively interested in database internals. The time commitment was average but would be significantly greater if you don't have prior front-end, SQL, or general web development knowledge. The project pacing seems to be a bit skewed and the final month is heavier with homework, project code/demo/report, and exams 2 all due. The two exams are fair and the second isn't cumulative.

This class was a major disappointment. We spent so little time learning frameworks like MongoDB and Neo4j, and instead used the majority of the time working on theory, most of which isn't applicable to the real world. We spent 1.5 weeks learning SQL, 1 week learning MongoDB, 1 week learning Neo4j, and 1 week learning NodeJS. This is simply not enough time to truly learn. Not to mention, the workload was intense, as most the homework has 10 pages of problems and requires mastery in a topic that you only spent half a week learning. Yes, the final project is really cool, as you get to build an actual application that interests you. However, it's simply not worth it to me. You'd be better off learning databases through self-studying, instead of taking this class. At least then, you'd spend more time on building and writing queries, instead of proving relational algebra axioms and functional dependencies.

This class touches on many topics like SQL, React, general web development, NoSQL. It moves at quite a fast pace, especially in the first few weeks, so some prior SQL knowledge will help tremendously, as well as finding yourself a good group for the project which you'll work on all semester. I found the class to be essential for someone who aspires to become a software engineer (which is most of us) so would strongly recommend taking it. Assignments are only due biweekly so if you start early, they are quite manageable. There are 2 non-cumulative midterms each worth 25% which I thought had good coverage and were fair in terms of difficulty level. This class has so much potential but still fails in some areas. For example, we spent only a week on React, but multiple weeks on the nitty gritty of indexes and I/O calculations which I've mostly forgotten already. If MCIT is meant to be a condensed program that gets people without CS backgrounds to find jobs in the tech industry, then its courses must be made more practical.

Pros: - Learned SQL, MongoDB, and Neo4J. Also exposed to Javascript, HTML and CSS, but not a lot of instruction on them. - Dr. Davidson's lectures are clear and well-articulated - Unlike other courses and electives, the assignment instructions are well-written, so that I generally understood what I was supposed to be doing - There is a lot of content and I got a good value in terms of the number of topics Cons: - This is the highest workload of any class I've taken at MCIT excepting only 593 and 596. - I felt torn in multiple directions by the need to work on a group project and individual assignments at the same time - The group project felt like it was about web development instead of databases, and there were hardly any supports or resources built into the course for it - Some topics, such as NoSQL languages, were so late into the course that they felt like an afterthought, but I wanted to spend more time on them - The course only takes a mathematical approach to databases, there is a TON of math, but not a lot of real-world applications or problems presented - There is a lot of jargon in the lectures and content which I felt detracted from my learning experience - I was so stressed out the whole time in this course and felt the learning curve and workload were too high and I didn't get any chance for topics to sink in - The difficulty and scope of the assignments (you needed to find 2 databases with thousands of rows of data for the final project all on your own) did not seem to enhance my learning experience; the challenges presented did not make me feel like I understood the concepts better when I worked through them. Writing more complex queries did not necessarily translate to a deeper understanding. I am not sure I would take this course again. My goal was to learn SQL and see if I enjoyed WebDev, but, I do not feel this course was a good fit for those goals in hindsight. I think this course can be improved by reducing the workload, adjusting the order of topics presented, reducing jargon and including more real-world applications.

This class provides the most tangible "resume boosting" experience for those looking to get into SWE - by the end of the course you will be proficient with SQL and have had significant exposure to MongoDB, Neo4j, JavaScript, and React. However, the lecture material can be dry and hard to follow at times, and the workload for the course is VERY back-loaded. The good: most of the content covered/skills acquired in this course is very much in demand. The professor makes herself available on Piazza even more than the TAs which was very impressive. The project is by far the most important project you can work on in MCITO - it serves as a "capstone" in which you find yourself basically using everything covered in the program to deliver a fully-functioning web application which makes API calls to a MySQL database hosted on AWS. The not so good: the material is not very engaging in some weeks - it feels like the professor is reading from a script and the result is it can be hard to follow along. The project milestones do NOT force you to pace yourself as I had hoped - I spent close to 40 hours per week in the last two weeks of the course because I had to learn React/JS and then apply that in the construction of the web app. My advice would be to start the front-end dev at least 4 weeks before the end of the semester if you can, to give yourselves time for the unavoidable roadblocks you will face (unless you already have web dev experience). Overall, I learned a LOT in this course that will serve me well in my career, and I would say it is the most important elective for those who want to go into SWE or even PM because these skills will always be in demand. I just wish the lectures were more engaging and the spacing was a bit better. But all in all, I am glad I took the course!

This class is primarily about databases and goes into depth with relational databases and gets a little into NoSQL databases (MongoDB and Neo4J). The project utilized React with Node.JS connecting to a large database. The amount of work you need to do for this course really depends on your partners for the project. I ended up having to do the majority of the work for our project which resulted in some long weeks. So make sure you choose a motivated team. Overall the class was good and worthwhile.

Didn't have too much coding experience before this class so it took me hours to get through homework. Wished the lectures covered things more in depth as the homework is more difficult than what is covered. TAs are super supportive and helpful though!

From this class, you will learn valuable skills that are essential for any SWE or programming job. With that, I believe you can learn these skills from other resources in about two weeks and without the hassle of watching the course's lecture videos which can be, at times, unnecessarily dense. I won't tell you what to do. But if I could go back, I would have chosen a different elective and spent a couple weeks learning the below skills from other resources. That being said, if you want a job involving work related to the underlying mechanics of DBs, perhaps this course is for you. The most valuable topics I learned from this course: -Basic database structure and what are/how to use primary keys/foreign keys -ER Diagram -What is SQL and how to write queries -What is NoSQL and how to write queries for MongoDB and Neo4J -Differences between SQL/NoSQL including advantages/disadvantages for each P.S. This course does not teach you web dev. Homework 2 touches on React and node.js but it does not provide adequate instruction on either topic.

After taking the course, I don't feel this course is as helpful as others described to swe. It was a very theoretical course, but it lacks continuity. The structure was loose and the topics covered from week to week were not related to each other. The quality of the TA wasn't good, as often I only saw one TA answering all the Piazza questions (but was rude). The instructor team wasn't transparent about the grading on final project, and our mentor (a TA) was non-existent throughout the process. The only thing I got out of this course was a full stack web, but none of the knowledge was gained from the course material or interaction with staff. I learned and did that with my awesome teammates.

I took the course with Prof. Naik over the summer and I like this course. I worked with a good team over the summer, and we learned a lot from each other. The course was made up of 25% Midterm 1, 25% Midterm 2, 25% Group Project, and 25% Assignments & Quizzes. I don't think either professor will make much difference, but having a good team will. Overall the skillset we learned was directly relevant to someone who is aspired to become a full-stack engineer.

A well-built course that provides a lot of good knowledge on SQL and NOSQL systems. I've definitely enjoyed this course a lot. I think the final project is a great culmination of the semester's topics as well. Things are prepared ahead of time, assignments are graded fairly, and TAs provide a lot of great help.

One of the worst courses I've taken in my schooling history. It's unfortunate because the professor was very patient and explained concepts very well in office hours, but the course was certainly not set up by him. The best part of this course is the final project where you work in a group to create a full stack web site. Although it's something you can certainly get done with free online courses, and to be honest, you'll need to do some independent searching for information - because this course really doesn't teach any web development. The worst part of this course is the grading. For assignments and exams, there is a mix of open response questions and multiple choice. The TAs might dock you for points even though you answered the question - but you may have missed some random bit that wasn't specified in the instructions. You can request regrades and they double down with more made up instructions. Some of the exam questions require you to write queries in an open textbox - and if you miss a parenthesis or quotation mark, you're losing points.

I did not like how this course was set up and found that the material grazes the surface of way too many database topics. I would rather the class focus on a few key areas of DBMS to avoid confusion and frustration for students. The homework assignments were very confusing and long. I found myself running out of time to complete two of them because I couldn't figure out what was being asked nor could I figure out where to find the information within the lecture material. The course requires a semester long project where you and a team of 3 others work together to build a web app that utilizes databases. This unfortunately required students, on top of the normal course content and assignments, to learn React and other web development topics on their own (so basically teaching yourself an equivalent of a web dev course with little to no guidance). I found the project to be extremely labor intensive and wish it was worth more of the final grade given the amount of work required. Each team is assigned a mentor TA that you meet with monthly to go over your project progress and they are supposed to provide feedback to adapt your project as you go. Our TA told us each meeting, including one before the final presentation, that our team was great and didn't need any changes, but then turned around and took points off for "not utilizing our databases differently enough". We weren't able to contest this because the class was then told once the project grade was released that we were not allowed to submit a regrade request on it. The main upside to this project is that it can be on a public GitHub repository which means you'll be able to use this as a portfolio piece. The course, and its staff, was completely disorganized. Students would make posts on Ed Discussion days leading up to the due date for assignments and still not receive responses from TAs or prof until days after the due date. TAs would give conflicting responses to student's questions which led to lost points on assignments due to this confusion. As mentioned, there was a semester long project. In the beginning of the semester we were provided with the spec on the project and in said spec students were told that they would have a chance at extra credit (up to 5% on the project grade) if their team's project won in any of these areas: Best overall, most complex/technical, and best looking. Many teams put in extra work aiming to win in one of these categories. The last week of class the project grades were released and no announcement of winners was given. I had made a public Ed post inquiring about the winners and was told by a TA that the staff had recently decided (without telling the class) that they didn't want to pick winners or offer the extra credit anymore. That infuriated me since I had to sacrifice spending more time on the last HW assignment for spending more time on sprucing up our project for extra credit. Thankfully I and other classmates were able to convince them to stick to their advertisement of EC from the beginning of the course, but I find it completely insane that the course staff would attempt to take away the EC without any prior announcement.

I learned A LOT from this course. I think it is very, very well structured and covers a wide variety of topics related to databases (especially given it's still an introductory course for DB topics). I disagree with other reviews about the lack of structure/unfair expectations regarding building a web application for the final project. The final project focuses its grading largely on database topics (everything we are taught through lectures) and the web application portions using Javascript are largely guided by an early assignment done early in the course and its related code templates. Furthermore, I'm very grateful that we were given a chance to wrestle with these challenging topics (DB and more) and were given the chance to integrate topics into a capstone project. I believe the guidance, lectures, and assignments prepare one adequately for success in this course. It's a lot of work, but I think that's an obvious requirement if you want to learn something completely new. The course staff and instructor work hard to provide a good learning experience in this course and I definitely had a fantastic one.

Just too easy. Needs a complete overhaul. Maybe make this an optional class or offer a harder version for people who'd prefer that. I'd taken only one other CS class in my life but I didn't learn much new here. Class averages were way too high on everything, AND there is a curve up.

550 is great- course material is extremely useful and interesting, the material is well organized, and the professor is good. The final project is a highlight of MCIT, and something I mentioned in almost all of my job interviews. You work in groups to make a full stack web app with a relational database, deployed over AWS. Most groups use React for the frontend and Express for the backend, both popular web development frameworks. This does require a bit of self-teaching to learn JavaScript, but it is definitely worth it. The homeworks aren't usually too challenging, though some of the theory can be tricky to understand on initial encounter. There are two exams, non-cumulative, both fair representations of the material learned, not overly difficult.

Many courses in MCIT will vary dramatically based on your background knowledge, but 550 might take the cake. If you have experience with (a) SQL and (b) web development, I can imagine this course being pretty average for the program. I had neither, so at times it was exceptionally difficult instead. The first two weeks are essentially a SQL boot camp, which I found brutal but valuable. My bigger issue came with week 3, where we were simultaneously introduced to HTML, CSS, JavaScript, React, and Node. The lecture materials provide a very light survey of these topics before you're given an assignment where you have to write several advanced SQL queries and integrate them in a simple React/Node-based web app—which, if you have no prior experience with web dev, is far from simple. Then you have the middle half of the semester, which focuses on database theory and involves some 595-style math. Contrary to many others, I didn't find this portion that grueling, but I have to agree that it's not very practical knowledge either unless you're looking to go into database administration. The final few weeks shift to NoSQL languages, which are fun but somewhat perfunctory, especially as everyone focuses on the massive group project. If you can do this project right, I think it's an invaluable asset ahead of SDE job applications. Unfortunately, I personally felt like I wasn't able to take full advantage of it, partly due to weird group dynamics but even more so because there was simply no time to actually learn the necessary skills *on top* of everything else going on (as mentioned, 550 absolutely did not give you that knowledge itself). So yes or no: do I recommend 550? It depends. If you either have a strong SQL base going in or are prepared for 2-3 brutal weeks where you go from beginner to advanced right out the gate, then great, that's the first hurdle. The bigger one is whether you think you can reach the final third or so of the course prepared to tackle the group project. I strongly advise anyone going into 550 to try and complete at least a basic React tutorial before they reach that point, because otherwise the course's biggest selling point, its professional relevance, will be largely moot.

This class changes so much every 2 weeks that you don't really learn anything well. Just when you start to figure out a certain language or technology you're immediately off to a new. Could you honestly look an interviewer in the face and honestly tell them you know NodeJS after working with it for 1 week? This class should be 2 or 3 things and stick with each for a month plus, not switch from one language to the next every week. I would not recommend this course.

There were a few good parts - learning the basics of SQL, MongoDB, and Neo4j, and setting up a RDS instance on AWS. Those 2 assignments (out of 6) were well designed, and the assignment on building web apps with React was useful enough for the project. While some of the theory seemed useful, the teaching was abysmal. I feel like this professor wants this class to be "rigorous" so makes the lectures, assignments, and exams as confusing as possible even when the ideas are simple. The theory is then never connected to practice, for example we go through relational algebra and calculate page IOs but never learn how to actually optimize queries in the real world. We also never learn about tradeoffs in database design, e.g. for a transactional heavy database vs a data warehouse and never practice setting isolation levels after learning the theory. The project was actually well designed, although the milestones were amateur hour -- the course designers definitely do not know best practices in web application building. I already have significant web application experience, so the project was fun and we went way above and beyond, but this course would be a terrible way to learn the important nuances of building websites. I would just take a course elsewhere for web design. All in all this course was the most annoying course I have ever taken.

One of my least favorite courses in the program. This was my first elective and not sure if this issue exists for all electives, but TA support is nearly non existent. You can post a question on Ed and not get responses to it for days. The professor is the most active in answering the questions. The TAs didn't care about your success and you knew it. The class is overall not difficult but what makes it hard is they don't release hw solutions at all. This hinders the learning experience quite a bit as we never really know what we did wrong; or if there was a better way to do a problem, we would never know either. The final project was a painful last few weeks. I highly recommend spending time finding a good group with a diverse set of skills (data cleansing, query optimization, front end). The project took me longer than any other project I've ever worked on in MCIT. If you're not familiar with the parts you sign up for, it will take you a long time so start early if you can. This was said in other reviews, but at the end of the course, you are jack of all traits (two weeks in SQL, one week front end, one week mongoDB and one week Neo4j etc) and master of none.

Weeks 1-2 and 13-14 were super interesting (SQL & MongoDB/Neo4J, respectively), but a lot of time was spent on theory that doesn't actually come into play when working with databases in the real world. That said, this course did a great job preparing me for interviewing. DB questions came up almost universally in the SWE interviews that I did. Overall, course was a lot of work (especially combining in the project/final exam timeline), content was a bit over-the-top, but it was super useful preparation.

This course definitely feels like it covers some of the most practical material in the MCIT program but the execution and organization were not the greatest. There's a lot of very different topics that are thrown at you and are covered only briefly before moving on to the next topic. For example, HTML/CSS, Javascript, Node.js, React were all covered in the same week, with only a brief introduction before an entire assignment was due the week after. Some of the topics like relational algebra and query optimization were also quite abstract and took a while to get through but were only covered very briefly. On the bright side, the group project is definitely something you can put on your portfolio, but it can also be a challenge depending how your group is.

Really good course, people don't like the theoretical weeks but having watched CS 186 (Berkeley's Databases Course) concurrently with this course, this is exactly what they teach (and more). The theoretical parts are also highly relevant for data engineer interviews/roles (how to normalize data, diagramming skills one -> many, many -> many relationships, etc.) and just generally good-to-know knowledge for all software engineers. Only frustrating part was dealing with the group project (would honestly lookout for bad teammates and being prepared to code in React/Javascript), and the grading system for this course is harsh (A, A-, B+ were 90.5/89.5/88.5, and then it drops to B which is 80.5...) with two heavily-weighted 25% midterms. I ended up with a 96% on the group project after putting in more than 60 hours into it, and 92% overall. This course is not for the faint of heart. And for those who won't put in the time for the group project - be warned, your teammates will grade you poorly as there is a peer assessment part.

Amazing lecture videos, good TAs and professor, fun and challenging homeworks, not sure how you could not enjoy this course to be honest, great way to start the program.

The hardest parts about this class are keeping up with the lecture material, completing the homework, and not making dumb mistakes on the exams. The final project, on the other hand, is pretty straight forward. Our group had zero front end experience and ended up using the skeleton of a past homework assignment for pretty much all of our final project's front end and we did fine. This was the "easy" way to approach the final project and is always a fall back option if you take this course. If you can, find group members that have some experience with client-server architecture. If you start moderately early and put in a bit of work each week, you can come away with a solid understanding of React, Node.js, and SQL. The final project is either a chance to get super creative or simply an opportunity to explore the basics of what it means to make a full-stack webapp. Careful though, the weekly assignments and exams are sneaky difficult.

For me this class was the most practical class I've taken so far in the program. I appreciated both the breadth and the depth of the material. The projects are time consuming but very rewarding. The web development component of this course had a steep learning curve for me but ultimately was very beneficial to my learning experience, and the group project tied the whole class together. I did feel that the first half of the course was better structured than the second half -- the last few units especially were very rushed, which is something to watch out for. After taking this class I definitely feel prepared to tackle technical data science interviews using SQL, which was my personal goal, and I appreciated exposure to HTML, CSS, MongoDB, and Neo4j. However (this seems to be an unpopular opinion) my favorite part of the material was the level of theory and mathematical rigor - these provided a deep understanding of the workings of relational databases, rooted in the fundamentals of relational algebra. Overall, I strongly recommend this class!

Well, this is a hard one to rate. The class starts very strong, effectively picking up where 593/595 left off by teaching you how flaws in C code could be exploited to gain root privileges. For a few weeks, I felt this would be the general format of the course, learn how databases, web interfaces, and applications work behind the scenes, and learn how to exploit well-intentioned code. Yet a significant portion of this course is dedicated to a deep dive into public key infrastructure, which is, unfortunately, a deeply theoretical discussion. And to summarize its major conclusion "don't build any cryptographic security tools yourself, use what is available and use it correctly." Which, based on my mathematical maturity, is certainly great advice. I wish six weeks weren't spent discussing the theory behind it and were spent learning how to use said cryptographic tools correctly. After the cryptographic sojourn, the final weeks pick back up where the first part of the course left off. You once again get back into learning how websites and browsers work and common exploits that can undermine those systems (spoiler alert, never click on a link). Also does <script> alert(0) </script> work here? If you get a pop-up this website has a security flaw. If you aren't comfortable with web development the last project will take a fair bit of time. But, once you get the exploits working, it is rewarding.

Take it! Pros: 1) The material is actually interesting, especially the web security portion of the course. 2) The lectures are well done; I appreciate the conversational way Professor Angel explains things - he's not reading from a script. 3) The projects are challenging but fun; it's very satisfying when you can get the attack to work. 4) You reinforce and deepen your systems knowledge (from 595) by learning about and conducting buffer overflow attacks. 5) It's really fun to learn about the web by examining its security issues and exploiting them. 6) Now I know what that little lock icon in my browser means. 7) I learned basic HTML and JavaScript in a very hands-on way (in the web attacks project). 8) There's not much hand-holding so you become more "scrappy" in figuring out how to do things; I suppose that's the ethos of hacking. 9) This material is foundational and will be relevant to any software engineering job. Possible cons: 1) I often felt frustrated at how long the projects took simply because we were left to figure out so much on our own; much of this was the kind of productive struggle that strengthens you, but some of it felt like wasted time that could have been saved with a few helpful clarifications up front. 2) The middle portion of the course goes into depth on cryptography, and some of the mathematics involved are tedious; but to be fair, you can't really understand cryptography without understanding the mathematical principles we use to define and ensure security. TLDR: This is not an easy class, but it's satisfying and valuable. I sometimes felt frustrated, but overall I learned so much, and I would definitely take it again. I would recommend it to everyone.

This is a good elective and I would recommend it, although there are a few kinks I hope will be worked out after this first semester. The content of the course itself is really interesting and a lot of it actually came up in my onboarding at work as a software engineer. We learned in equal measure about classic vulnerabilities in C programs (fun for students who enjoyed 593 and gdb); the mathematical theory behind cryptography; and modern web vulnerabilities. Prof Angel is a fun lecturer and his open office hours are great — he knows the course material well and can dive into industry applications as well. The coding we did in this course isn't necessarily about best practices of any specific language (C, Python, JavaScript) but about being able to hack together something that works in those languages. Some cons: we didn't have any TA-led live events such as recitations, and didn't have any practice ungraded assignments to learn from for assignments/projects. Support on Piazza and OHQ could have been better; private office hours were often cancelled/rescheduled last-minute. Weekly quizzes were single-attempt which caused unnecessary stress, although the lowest 3 scores were dropped at the end. In general the course was a little more difficult than I think was necessary because of these reasons. On exams: they were open-book/open-resource, though still difficult because they ask for application/critical thinking behind the theory we learned in class. Midterm median was 74% and final median was 85%. Overall: This class was one of the most challenging — but also one of the most rewarding and interesting — courses I've taken in MCIT.

My favorite course in the program so far. If you enjoy computer/cyber security concepts, this class is a must take. You will have projects in buffer overflows, attacks on cryptography, SQL injection, and web app vulnerabilities.

Interesting content with highly-applicable hands-on projects to actually understand what is being taught. The projects & HW are a lot of work, and there are extra credit problems that dive even deeper (and are even more work, with a couple at the end actually being unsolved problems). I appreciated that most of the projects and HWs are based on actual attacks that happened to companies or open source software. Weekly quizzes are only 1 attempt and only 2-4 questions, which are high-stakes given the quizzes are 15% of your final grade, but your lowest 3 quiz scores are dropped (so only your best 11 quiz scores count). Proofs popped up for a couple weeks which was an unpleasant surprise, but it’s not as intense as 592 & 596 as far as proofs go (there is a specific "security game" formula for proofs you learn). The content is split into 3 overall sections: C vulnerabilities, Auth/Cryptography/Encryption (with surprisingly only a small amount of overlap with 582), and web security. There is a crash-course in HTML & JavaScript, which is mostly the first 2 weeks of https://www.edx.org/course/programming-for-the-web-with-javascript, and the majority of the videos are optional (they’re just included if you’re interested). The final project does involve HTML & JavaScript (including jQuery), which is straightforward if you're already familiar with web development, but still a decent amount of work, and if you're not familiar, you'll learn what you need to quickly! Best part: the final is not proctored!

I really enjoyed this class! I think it has a good coverage of security topics. The class consists of 3 parts: 1) hardware attacks (require you examining stack and using pointers) 2) Cryptography - very theoretical and some math involved (modulus and exponents) 3) Network security - web based attacks. - Pros: contents are interesting, professor is knowledgeable about the topic. projects are fun, like opening backdoors; injecting code in a website etc. - Cons: projects can seem open-ended (but not really) and can get frustrating, I had spent hours trying all kinds of tricks and still not working, went to TA office hours and turned out I wasn't looking in the right places. Always go to OH when you are stuck! - Not a pro or con: exams scores don't add up to 100 - kinda bugs me when it says a question is worth 3 points, but the total is 58 or something, so it is really 8.6 points for that question which is a lot.

| Material | Broken up into three major chunks: low-level vulnerabilities (e.g. buffer overflows in C), cryptography (starting with historical ciphers and then transitioning into modern cryptographic objects), and web vulnerabilities (e.g. cross-site scripting with JavaScript and jQuery). Depending on your background, you may need to put in more work in some areas. I had previous experience with C (593 and 595 are required pre-requisites), so the first third felt pretty intuitive, but the remainder was either maths (probably around the 592 level but different application) or web dev (no prior experience). But you won't be building a web app a la 550, but rather breaking an existing one. I recommend starting the projects early in case you find that you need more time to pick up the necessary bits of a language. This course uses C, Python, JavaScript, JQuery, HTML, and technically CSSs but I did not find CSS necessary. | Assessments | There are weekly content quizzes in Coursera, and apparently the bottom three are dropped (we just found out after final grades posted). There are four homework assignments that are short answer. These are based on course material or required readings, generally more on the theory side of content, although one felt more like a project. Three projects are applications of vulnerabilities covering the three major chucks of material. These are mostly autograded. Two exams, with the split between the mathy chunk. | Overall | The material is definitely interesting and provides some good background on security of computer systems that is probably applicable even if you're not planning one becoming a software engineer. The optional readings aren't assessed but worth the read anyway. The instructor had office hours twice a week and really helped clarify some of the more difficult topics. This is the first iteration of the course, so obviously there are things that could be improved, some of which occurred during the semester. The TAs were good but I'm hoping there will be more in the future.

This was a good class, but not a perfect one. The topic is fascinating. I learned a ton about a wide range of computer security issues. I liked the professor's lecture style. I also think I have a much better foundation on general web security issues. It's a great course, and I recommend taking it. That being said, there were a few negative aspects of it. 1. Lack of TAs - The TAs were great, however there weren't very many of them, so it sometimes took a while to get help on an assignment. Additionally, there aren't any recitations which would have been helpful. 2. Too Much Encryption - We spent 2-3 weeks on low level stuff, 6 weeks on encryption, and 4 weeks on web security. I thought the class was too encryption focused. I loved the low-level attacks (buffer overflows, etc.), but I don't think we spent enough time on it. 3. Assignment/Test Scheduling - This class felt like it was staggered strangely. The last project ended up being the most difficult, but we only had 2 weeks for it (along with another simultaneous homework + studying for the final). Aside from all those complaints, I think it's a great course that achieved its goals. I would take it again.

One of my all-time favorite courses! The material and projects were super interesting, the instructor and lectures were great, it covered a lot of interesting topics but also managed to go into a certain amount of depth on all of them. There were 3 main parts focusing on application security, cryptography, and web security. There is a strong focus on cryptography which I understand isn't everyone's cup of tea (there was a lot more discussion of mathematical concepts than I expected), but you do projects and homework assignments where you get to apply the theory in fun and interesting (and challenging!) ways, so I ended up still enjoying that part. The projects tended to be really time consuming, so it is definitely not a light course, but I thought they were well designed and I enjoyed all of them. Note that the application security part of the course goes into a lot of detail on C, the stack, and assembly language, so if you hated 593 you probably won't like that part.

<script>alert(1);</script> By taking this course you will know what something like this means and examine each website with a completely different mindset. You will learn how to manipulate stacks to your advantage, and have a whole new perspective on the code you wrote in 593 and 595. You will have a much better appreciation for how things are actually secured, by diving deep into common hashing, encryption and certification schemes such as RSA, SSH, SHA256 etc. This is a course that teaches you very little actual coding, but requires you to really use coding creatively to solve problems. Be prepared to spend a whole lot of time feeling frustrated at homework. Be prepared to feel lost in exams, but through these challenges, you truly learn a lot. However, due to the huge amount of time needed, I do not suggest pairing this course with any other courses, nor with any other out of school commitments. This is a course best served alone!

This is a really interesting class that does a good job covering both the theory behind security as well as modern tools for preventing attacks. Professor Angel has a clear and accessible lecture style and was able to break down some really tricky topics into a way that could be easily understood. With that said, this class is very, very challenging. I found it comparable in difficulty to 596 if not slightly harder at times. I would only really recommend taking it if you truly have the time to devote to it. Unfortunately, due to a full time job and variety of other commitments while I was taking the class I wasn't able to devote as much time to it as I would have liked. As others have noted, the assignments are quite open-ended and are designed in such a way that you have to figure out a lot on your own. They're only really a positive learning experience if you can do them without feeling rushed and take the time to explore different approaches. Thus, if you are genuinely interested in getting the most out of 551, I would recommend having a light schedule outside of it.

Not going to lie - this class takes work. However, I really enjoyed learning the ins- and outs- of major areas of computer security. The projects approach the topics by having you construct working attacks, which was probably the most fun and interesting way of learning this. Also, It made me never want to construct an app that requires user input (lol). Lectures are good, Prof. Angel adds enough humor to keep them engaging. Assignments take time - do not wait to start them. As someone else posted, there's a lot of "productive struggle" in the assignments (the professor stated this up front), but sometimes it presented an impediment to just getting started. My only real gripe is the grading structure of the class - assignments contained very few points, and partial credit was sparingly applied, so missing a question or two here and there sometimes took a chunk out of the overall grade.

Remember Dijkstra? Ever wonder what would happen if the nodes in the graph could send messages back and forth? In Networked Systems, you learn about the nitty-gritty details of how computers talk to one another as well as the implications of their discussion. The algorithms covered in 596 take on a different color in a distributed setting. The course focuses on the data link (bridges/switches), network (routing protocols), transportation (TCP/UDP), and application (peer-to-peer overlays) layers of the OSI model. Dr. Loo's explanations of the material were refreshingly detailed and well diagramed. The project is among the program's most rewarding. Your task is to implement the routing protocols that drive today's internet and construct a basic peer-to-peer search engine in a group of four. Have a strong group pre-selected for the course as it will make your life easier and the class more rewarding.

This is a very group oriented course so I think your experience will really depend on your group. I had a really difficult time through the group project that made me lose faith in this program and the staff. There is not a lot of support for this course. The professor and lectures aren't bad and the group project itself will teach you a lot about networking and Github. The material isn't shockingly difficult, but my group project experience was absolutely awful. I don't think I've ever had a group project experience as bad as this one.

Even though I found some of the lecture content (hardware and electrical engineering-adjacent material on the lower network layers we learned about in 595) and delivery a bit dry, I still highly recommend this course to not only students interested in systems but also those interested in software engineering at large. The projects were a lot of fun and I believe this is the only course so far in the program where we're able to work in an industry-sized codebase rather than a toy project — don't worry though, the TAs split out the codebase and work into bite-sized amounts so it's manageable with your group of 4. Similarly to 595, the course workload is extremely light other than the amount of time the projects take. For those who want to go above and beyond, there's no shortage in additional hands-on learning opportunities with all the project extra credit options available. The best part of the content, in my opinion, is that the class teaches, and has us implement by way of the projects, really interesting and industry-relevant distributed systems concepts: the theory behind a lot of graph algorithms when we don't know the entire graph; and large-scale systems design concepts such as exponential backoff. Finally, we all know Professor Loo's patience and fast Piazza answers from 595, but in this course he really shines as an industry expert in the field. He's actually founded and advised startups in this industry, and was able to relate many of the theoretical concepts with actual open source projects, tools, and companies off the top of his head during open office hours.

This class is great because of its projects. The lectures are light and introduces many system designs involved in networking protocols and DHTs. The OOHs were great where prof. Boon talked about many interesting topics like video streaming, content distribution, datacenter etc. The real value of this course comes from the projects which I think gives you a lot of software engineering skills like reading an already developed codebase and using the API's in it to extend the codebase to support new features. This course will force you to learn git in detail where you will be branching, merging, and of course handling merge conflicts. The projects have plenty of interesting ECs which if you implement, you will have an system almost similar to their real deployed versions. So, I would recommend this course to anyone interested to learn network programming and gain software engineering skills at large.

I came to this course with a deep background of photography and finishing it with just that and no additional knowledge. The course covers many specific topics with no content that binds them all together. Where are the overviews, summaries, interviews, industry-wide application examples? The Prof jumps to the course content directly every week and goes deeper and deeper into the subject with no hint whatsoever on how that knowledge can be applied. The only link between the course content and assignment was the TA office hour. Without it, one could never dream of working on the projects. There was very little learning about the actual course content in the projects. Instead, the key learning was always about numpy, dealing with arrays, matrices, hacks for getting things to work in python. It was a huge disappointment taking the course!

This is a critical subject area that all computer scientists and software engineers need to be familiar with, making this a course that most students should take. However, I feel that the course itself fell flat overall. Yes, there is a very interesting group project that covers routing, distributed hash tables, and distributed search. It is a great way to learn those concepts. However, the project specs are not very well-designed for group work. You can work in a group of 4, but it is very difficult to break the work up. Many times this required synchronous code-alongs which, while good for peer learning, are incredibly difficult to arrange for working adults who live far apart. It felt like everything took far longer than it should have because of this. Additionally, the project often lacked guidance, further causing a bit more wasted time; team of 2 or team of 4, it probably would have required the same amount of time. The project was hard because of inefficiency and ambiguity, not necessarily because of the topic itself. That said, good project, just needs better design. As for the lecture material: I have never found Boon's videos to be effective. I did, however, find the textbook to be solid. I read it cover to cover and feel that I got a good bit out of it. Luckily the course follows the textbook for the most part. So, if you don't get much out of the videos, you can just read the textbook (you can get the PDF for free). The best content from Boon and Kim came in the form of the recorded office hours, which were like the missing lectures we should have had all along. Although not of high video/audio quality, the content is quite engaging, as we watch Boon draw out the network and interaction between the various components. The tests are surprisingly tricky, albeit open book. Most questions require thorough answers of at least a couple of paragraphs (some shorter, some longer). Average grades were not good, but they might be curved. The project was worth more than the exams, so completing the project will bring your overall grade up. To succeed in this course: Proactively find a good study group from day 1; interact with each other frequently via Slack and Zoom. Agree to some methodology for managing the project and make sure everyone knows how to use Git. Start on the project as early as possible. Read the textbook first, then watch Boon's corresponding videos. Watch the recorded office hours from previous semesters.

I liked the class because it had stellar staff support and opportunity to learn the network programming with hands on project. It had lighter workload when the project deadlines were still weeks away. However, do keep in mind that the course project (there are 2) used C++ and the code base was industry sized (not your average toy project). The main challenge was to team up and start tackling down the project by milestones. The TA office hour and recitations were very helpful when you got stuck, and the professor was kind and knowledgable whenever you have questions from the lectures. He's always ready to teach in the OOH. I strongly recommend go to the OOH because the lecture itself might be a little dry.

If you want to learn how networks and distributed systems work, this is the course for you. The course is comprised of 3 open book exams, which are very fairly graded, and a 2 part project. The project is made for groups of 4 (and I think it's required you have a group of 4) and is where most of the learning will take place. You'll build a distributed network capable of handling node failures, all from practically scratch in C++ Whether or not you have a good time in this class weighs heavily on the groups as the group project is pretty intense and requires good collaboration as you'll be doing a lot of code merging/pair programming. The professor is awesome, the exams wont break you, and you'll learn a lot!

Very interesting lecture material. Great introduction to distributed systems with a strongly correlated practical projects. The projects were hugely helpful in understanding the theory and putting it in context.

There are two substantial group projects in this course, completed in groups of 4. I enjoyed the projects and found them to be very challenging and time-consuming. (These projects are much more challenging than the 4-person group project in 550, say.) It was key to go into the class with a group of students I had worked with before, as we spent many, many hours working very closely together. I would not take this class again if I were not already part of a group I knew well before signing up. Given the difficulty of the projects, I appreciated the light lecture content and easy open-book exams.

The most enlightening aspect of the course is the opportunity to attend Prof Loo's office hours. Even though for most of the time, not many of the coursemates are showing up (which I think is a shame to pass on the opportunity to interact with one of the industry experts on the subject matter), he still provides lots of insights regarding the coursework and beyond the materials. I personally enjoy these opportunities. In terms of the course content, there are some overlap with CIS 5490 when this course touches upon TCP and wireless communication. The two projects (basically one whole project, but split into to 2 parts and subdivided into milestones) requires some deeper understanding on the concepts present in the lectures and their implementation in C++ and ns3 library. Once you get the mental model of the whole project though, the required bits are not that hard to finish, especially with competent teammates. The project has plenty of EC opportunities for the interested students to delve into and learn more. I have even implemented an incremental version of the Dijkstra algorithm and made it work in one of the ECs I attempted! That was one good piece of code that I would not forget anytime soon. I would recommend the course for those who wish to have some deeper understanding on networks, systems and software engineering. This course would give you a taste of working in a large code base and collaborating with teammates, in a low-level language and implementing algorithms that form the basis of the modern internet.

Excellent course. A lot of work. In many courses, you could complete the final project yourself if you really had to. In 555, that would be impossible. You need a stellar group to succeed.

Though I'd heard this complaint before about other courses and never found it to be true, I agree that the assignments and the lecture material are fairly disconnected, and as a result you should expect (and indeed you are encouraged) to read documentation while completing assignments. While that might sound like a criticism, I actually kind of enjoyed it - I presume this was done to simulate what it is actually like to work in such an unexplored and immature space. That being said, while it's unreasonable to expect a four month course to teach you everything there is to know, I wish the course had branched out to various crypto a little less and focused more on just ETH and BTC. Even as an avowed crypto skeptic (and now more certain than ever that I am correct), I found it very interesting to learn more about this material, but in retrospect, if there had been a course on cryptography, I'd have taken that instead.

Super interesting topic. Good lectures. But... I dropped the course after a month, since the massive amount of time, I spent on HW, was too frustrating for me given the return. For me, the HW were too much workload. From my point of view mostly because there is a big gap between lectures and HW (meaning I couldn't transfer much from the lecture to the HW), and within HW, instructions make sense if you know what is meant. I didn't, so there were too many passages, where I did not even know what the goal of the particular passage was. That was burning tons of my time while some more details in the instructions could have easily avoided that for me--without giving away the learning curve. On the one hand, the class aims to throw you into real life business waters ("go figure it out yourself style"). On the other hand, IMO those real life business waters typically come after you had the training wheels on at university (and in this course, the training wheels were too small for me). Also, I personally didn't like that the coding is a very low puristic Java level. Goal of the HW (at least the ones I saw) is basically to replicate features of commonly used libraries without using them. I would have learnt more, if the HW would teach you how to properly apply the commonly used packages, since this is what I am typically doing in my real life business scenario. I think it would be great to split the course into two courses (it is odd to me that the instructors perfectly know the feedback from students that this course has the workload of substantially more than 1 course unit). In the first course ("teaching you how to drive a car"), you get to know the main concepts and apply them with commonly used high level packages in HW--basically keep the current lecture and design new HW. In the second course ("teaching you what is going on under the hood"), you code on a low level in the HWs, while the lectures pick up the underlying concepts--basically the current HW with new matching lectures. The split into two course would naturally relax the high workload. And I think the first course would be more MCIT friendly and--even though there are students that score well in the current course--the first course would be more applicable to a wider audience of the MCIT program, including me.

This course has been the hardest I have taken throughout my entire MCIT journey. The HW assignments ask you to build a search engine incrementally, which will come into fruition in the final project. The HW assignments alone take a long time, especially if you want to get all the edge cases right. There is a public test suite available to make sure you get the basic functionalities right, but the hidden tests are very robust and will definitely catch you off-guard if you were not careful. The project was very demanding, and in order to deliver something in the end, you need to get every step of the sewrch engine right, from crawling to ranking to integration with the frontend, so you must apportion your time very wisely. Overall this course has made me a much better software engineer and I would really recommend anyone who wants to experience creating a project from the ground up at least once in school to take it. The reason I did not super like this course was that it was very very stressful and challenging, and in this first offering there were a few things the teaching team needs to tweak to make this a well-administered class. Hopefully in the next offerings these wrinkles would have been sufficiently smoothed

Coming from a non-IT background prior MCIT, with only 591-596 under my belt, this course was far more than a stretch for my abilities and mental health. Mastering the high workload & expectations in abilities for the whole semester has put me under huge pressure. I would welcome if you/the university seriously considered to make this a 1.5-2.0 credit course as this would better reflect the effort that this course requires. To me, keeping the workload manageable for students is an important quality that I missed in this 1 credit course. As a full-time student, I took the course because it was the last opportunity to take it prior my graduation and I wanted to embark on a challenge that advances my java programming skills and understanding of the web. I really valued the lectures modules as they span a variety of topics that also tie in well with other courses of the program (e.g. 582 Blockchain & Cryptography (old version), in which being familiar with http request & response was great for homeworks; 555 also added for me an additional view on the 582 encryption deep dive topics). For me, mastering homework assignments based on the lectures would have been impossible without extensive TA sessions in the first half of the course. Most TAs though were really great and engaged, the best TAs I have seen so far throughout the program. The homeworks really stretched the understanding from lectures and often I could not see why I would code something in a certain way for it to be useful in a later homework or the project. I would have loved to get more hands-on coding insights from the professor to even further improve my coding style. I could also well imagine a separate course for advanced Java programming (e.g. hands-on coding to deal with concurrency, or extensive & right use of the logger, was not part of 594). (O'Reilly books are a good resource but did not feel sufficient to me) For the final project, it would be great to have access to a list to see which TA was responsible / had experience in which project part. It would also be great if one could reach out to respective TAs who were responsible on the same project part more on a 1:1 basis, rather than only EdStem & TA Office hours.

This class is exceptionally well put together and informative – probably the best course in the whole program. I'd say it's likely more useful than even the other 'classic' courses like 5500 and 5450, and there's plenty of crossover with these courses. Unfortunately, this class is also way too much work for anyone doing this program part-time. The assignments are incredibly lengthy, probably 2-3x as much work as any other course I've taken (this was course #10 for me so I think that's a fair assessment of the workload in comparison to the program as a whole). Expect to spend 20+ hours on the weekly assignments. If you can, start the first assignment on day 1 and don't stop – you may be able to build up enough of a lead on the assignments that you never truly fall behind. In my case, I had to take a week of PTO mid semester in order to work exclusively on these assignments and get far enough ahead that I could realistically continue to work and not get fired. The lecture videos are excellent, and the professor was extremely responsive during the course, so on all measures besides the workload this course was 10/10. Just be very cautious when enrolling here that you do in fact have enough time to complete the work. If you do, it's worth it. If not, it won't be worth it as you won't have the high quality project to show for it and your mental health will most certainly suffer.

This is a pretty difficult class to rate since it's new and a lot of details are still being ironed out. The best part is the lectures which, for the most part, are well-made and informative. Prof. Haeberlen has a very concise lecture style and tells you what you need to know directly without any extra fluff. He does tend to speak very fast though to a point where I'd need to rewatch parts to catch what he was saying. The course is less strong when it comes to assignments. The first nine weeks have weekly homework assignments which were all long and tedious and then the rest of the class is spent working on a group project which is very challenging. I would say the homework assignments were roughly comparable to the Solo Project in 594 in terms of workload and time required except here you're doing them once a week. The consensus seems to be that the weekly assignments take about 15-20 hours to complete but certainly could be more in some weeks. Later weeks when you're working on the project will probably require even more time. This is separate from watching lecture, reviewing, taking quizzes, etc. On one hand, the assignments were a great way to get familiar with the Java API (especially with multithreading) and with designing a large scale program; however, I'm unsure of how useful they really were from a pedagogical perspective. The first assignment is building an HTTP server completely from scratch and then later on you build other tools like a key-value store and a basic version of Apache Spark. These all are used for the final project which is essentially building and deploying your own version of Google. While I understand that the benefit of these projects is to have us become familiar with the inner workings of these existing tools I felt as though they weren't entirely useful for a couple of reasons. First, we were making pretty trivial versions of all of the tools. For example, our web server could only use HTTP 1.1 and our key-value store was very simplistic and incredibly inefficient (tip: this will be a huge bottleneck for the project, spend a lot of your time fixing it upfront or the rest won't work well). Thus, we weren't really getting a full picture of how real world tools like Amazon S3 work when we were basically just making minimal viable product versions of them (which is already very difficult to do). The ones we built likely have little in common with the real versions and can only perform a small subset of their functionality. In a real world setting, the programs we built would likely be pretty unacceptable since we were incentivized to focus more on their functionality rather than good coding practices. Second, I feel like we would get more out of this class if we had the opportunity to use already existing tools. In my opinion, the final project would be a lot smoother if we could actually use Amazon S3 and Spark rather than spending most of the time trying to perfect very basic versions of both that work just well enough to make our final product function but would be pretty useless for most other applications. The lectures already give us a good background in how these tools were built behind the scenes plus we'd get familiar with how they actually work in practice and would be well prepared to use them in our jobs post graduation. Throughout this semester, there were many occasions where assignment requirements were modified because of bugs people found or changes in what the professor wanted us to work on. This required checking Ed Discussion pretty frequently to make sure you didn't work on an old version. This probably will be less of an issue in future semesters but it's definitely something to be aware of. Overall, I'm not really sure if I would recommend this class. On one hand, I learned a lot about system design and how the web works but on the other hand the assignments were quite long and stressful most weeks and took away from most of my learning since I had to spend most of my time doing the homework (which rarely felt useful) instead of focusing more on the lectures and making sure I understood them at a deep level. I would only really recommend taking this class if you feel like you can set aside 20-30 hours a week for it otherwise you'd be in for a very stressful semester. If you work full time I would definitely not advise you to take any other classes along with 555. As a bit of a comparison, I would say 555 has the workload of 593 with the difficulty of 596. It's without a doubt one of the hardest, if not the hardest, class in the MCIT program. Looking back at it, I probably would prefer to read a book or take a Udemy class on system design and take another elective instead.

This is a course which I liked very much but would only recommend this course to those who will be able to spend significant time in this course (the project may require upto 30-40 hrs/week). This course is an advanced programming course in java so you need to come with at least intermediate skills in java programming and be comfortable writing substantial program every week roughly comparable to the final projects in the core courses. My only java skills were from CIT5910, and CIT5940. So, it took me some time to get acquainted with threading, lambdas, streams, but taking this course has greatly increased confidence in my programming skills now. The topics covered are also super important for system design interviews and mostly focuses on the existing systems and how they have been designed.

This is a very chllenging but useful course. For me, 555 takes around 15-20 hours per HW, if with EC then sometimes it can go up to 25-30, depending on the score you want to get (A or just passing). I found the EC costs more time but also make you learn a lot more, and it becomes handy when the final project uses our own homework implementation of server, key value storage, mini Spark, crawler, indexer and page ranker altogether. The course aims at introducing the basic structure and design of distributed system, so the services we built in homeworks weren't super fancy but they are certainly a good introduction of the concepts, and exploration of cloud services offered these days. Each homework has 15 points worth of EC, and that all goes to making more features on your implementation, that time is totally worth it if you like to be extra (like me)! I have to admit the schedule for homework is very tight. There's no room for break, since those deadlines are one week in between. Content wise I agree with what people said in MCIT Central and Slack. The topics are broad, but not as in depth when compared to some other electives. It's certainly fun topics and a reliever that we don't have to deal with complex lecture AND homework at the same time, though. The exams were open book, and not as difficult as the homeworks. I didn't have to spend too much time worrying about them. I took the class during Fall 2022, its very first trial offering. The professor re-designed and used the brand new homework assignments. Given the circumstance, it wasn't too bad, but I wish there were more help for the questions we had on the homework and autograders, since no one except the professor has finished the version of homework we got, we mostly have to rely on the professor answering questions and clarifying things. (The professor was awesome and very responsive!) I was lucky that I'm not working this semester, otherwise I'd be a little more annoyed by the various bugs/improvements we discovered during the term. Improvements: starting spring 2023, the instructor team developed and tested the autograder for 5550. The on campus and online cohort used the same version of homework which utilized Github setup and Gradescope autograder. As such, I believe it becomes more friendly to students, but would still advice those with at least intermediate Java coding experiences and sufficient time consider taking the class. I personally agree that this may be one of the most useful electives of MCIT/CIS if you want to go with software engineer route.

Conceptually, this class is awesome. The topics covered are really fun and apply a lot of interesting math and programming techniques. Unfortunately, the class is really shoddily put together. The instructions on homework and projects are extremely lacking in detail. The lecture videos do a good job of covering high level basics, but you need to know some pretty fine details that are never covered to succeed on the homework and projects. You need to know python, numpy, linear algebra, and multivariable calculus all to some degree. And basically none of these things are really taught to you in this course; they are either extremely glossed over or completely omitted. It's extremely frustrating to say the least. Instead of providing what you need in lecture or in the instructions, you have to wait for the TAs to post a walkthrough for every project before you can even begin. And most of the time that isn't enough, so you also need to either attend the live session where they talk about it (scheduled for Fridays at 9pm, of course), or watch the recording. Sometimes these aren't available until 2 days before the projects are due. TA support is almost completely missing in this class. Questions on Piazza are often answered days later. When you do get a response, it's often subpar and only half answers your question. Ultimately, I am leaving this class largely disappointed and feel like there was a lot of wasted opportunity.

This course is essentially a copy paste from previous courses and online material. The HWs are impossible to accomplish from the lectures alone. You seem to be tested more on your numpy, scipy, python familiarity more than lecture material for the projects. On pretty much every project, I understood the theory of what needed to be done, but I had to spend hours figuring out how to implement it with numpy. It's a good thing then that the projects account for 55% of the course grade Their grading system is the worst I've seen out of any other course in MCIT. Their 3 HWs account for 15% of the course grade. Which means that each HW is 5% of your final grade. Now, alone, that might be fine. But they grade HW out of 10 points instead of a padded point value like 100. What this essentially means is that TAs are forced to take off more points than they would otherwise. For one particular hw, there were only 3 questions. Messing up one measly question means that you lose 1.667 points off your final grade.... for one incorrect question. On top of all of that, we NEVER got feedback on anything we got wrong, because they were too lazy to make new problems for subsequent semesters. They did not ant to reveal the answers. What this amounts to is never knowing what we actually did wrong. How in the world do you improve if you got no feedback? I would ask specifically for more feedback, and they would not give it. The icing on the cake is how unaccepting they were of their own terrible course. There were a few times when I needed the benefit of the doubt... as it has been a crazy semester with a lot of personal matters going on. They did not even budge the smallest amount. I don't know which kingdom the professor thinks he rules over, but we are human down here. I probably would not recommend this course to anyone. The lectures are even ripped off slide for slide from his older courses. I don't think he put any real work into this course. I think you'd be better off watching online resources than taking this course.

I have very mixed feelings about this course. The topics were interesting, I felt like I came out with some good foundational knowledge about CV, and I got to make some cool things in the assignments/projects. But overall the course was stressful, especially since I had never taken linear algebra (which is not a prerequisite but basic knowledge of it is 'recommended' - you will have HW assignments that require it). I think it's the kind of class where the TAs can really make it or break it, and I have to say that in spring 2023 they were not helpful most of the time. In the end you can still do well if you put in the work, though. I do recommend doing the EC project, even though it doesn't necessarily have a big payoff for your grade, because that was by far the most enjoyable thing I did in the class and it was a cool way to apply what I'd learned. I know a common complaint about this course is that it's dated because CV has come a long way in the last few years, or that there's too much focus on some of the more basic image manipulations, but that didn't really bother me - I think a lot of the stuff we learned was still interesting and reasonably relevant. You'll get good experience working with multidimensional numpy arrays and vectorizing code, which is super useful! And with the extra project there is room to explore some more state of the art stuff.

Great intro to computer vision. Course materials included both classical computer vision (e.g. edge detection, image transformation, image morphing, etc.) and neural network. Professor started doing social hour every week in the second half of the semester, which gave us an opportunity to get to know the professor better and ask questions. The projects require familiarity with Python and NumPy

It's a good course. The prof is great, the TAs are real helpful, you will do well if you put in the work.

Fantastic course into CV. Lectures are pretty informative and clear, and the TAs were super responsive and helpful. Most of the course teaches classical CV (manipulating matrices to transform images), then the last few weeks you make models (predicting on images). You get to understand the behind the scenes of what Photoshop or any other photo editor does, and honestly every week my mind was blown in lectures. This was my final MCIT course, and it has been my favorite (amongst 591-596, 550, 521, 582). I do think it helps if you come with linear algebra and Python knowledge. I had medium-advanced knowledge in both areas prior to the class, so take this review from that perspective. Most weeks, I did lectures in 2 hours and homework in 3-5 hours, relying heavily on the TA walk-through videos to get started. Previous reviewers seem to have different opinions on this course... Maybe the course staff adjusted? I didn't feel some of the things mentioned from past semesters, and would strongly recommend.

Despite the other reviews, I'd say that this class has great content. Topics are super cool (at least for me), but I have to say though, this class suffers A LOT from the Instructing team's assumption that the students are generally already able to do a lot of linear algebra and stuff. HOWEVER, doing this class for a good 3-4 months, I came to realize that while the lin-alg and numpy topics are heavy, they are very REPETITIVE (!) All we need at times is just either inverting matrices, transposing matrices (or both), solving the resulting matrix equation after the transformations, plus the simple matrix addition, multiplication, etc operations. Thus, a class like this ADDED WITH an even one class or recitation about doing the matrix transformations (+ how it translates to numpy) would be superb.

This is very good introduction to robotic course, but this is not an easy one. I agree that you should least some foundation in multivariable calc, linear algebra, trig, and hs physics before taking this course. I am working full time single parent with young kid at home from design background. the last time I took some serious math course is like 15 years ago (though I took some coursera multivariable calc, linear algebra...), so this course is difficult for me. I am able to work out the answers and labs on my own with a lot of time and devotion to understand and following the content. Though it is allowed to have a team member working on a all homeworks togather, I did not find one (retrospectly. I strongly encourage people to get a homework partner) due to my messed-up schedule and time zone. However what I found most frustrating is the technical platform (virtual machines) that is difficult to use and constantly crashes. I did not ask for clarification with TAs but did required many extensions which are granted in time without too much hassle. I generally pull about 2 all-nighters + some day time to do the homework each week(20-30 hours). But overall, I really enjoyed the content of the course. Even though I may not get A in this but the content is well organized and well delivered. the assignment (though difficult) is well structured to reinforce the learning of difficult concepts. I am amazed for the progress that I made with the course in such a short span of the time.

Summary: Overall, this is a great course if you have the time to focus on it and are up for a challenge. I don't have a mechanical engineering (or any engineering background for that matter) background and I learned so much in this course. They told us this is basically the MEAM 520 course with some changes so yes it is more mechanical engineering than CS. I have taken calc, but it's been a while and I'm pretty well versed in linear algebra. You will want to have at least some foundation in multivariable calc, linear algebra, trig, and hs physics before taking this course. The labs use python (and numpy) but you could probably pick-up what you need during the course even if you have never used python. This was probably the most time-intensive and conceptually difficult course I have taken so far and I've had all As in 7 other courses. Even if you have a mechanical engineering background, this course is still going to take a significant amount of time because the problem sets and labs are just a lot of work (especially the labs). If you have this foundational knowledge, the interest in the subject, and the time (18-20 hrs per week), I would highly recommend taking this course, despite the flaws I go into below. If you are working fulltime, I highly recommend taking this course by itself or with a very very light course. Now the Areas of Improvement: The lectures are pretty good, but need more examples. The assignment instructions sometimes require some translation, but there are no recitations going over them so you waste a lot of time clarifying things on piazza. The TAs this semester were terrible- probably the worst I've experienced. They typically didn't know what they were talking about, said contradictory things, and even when they did know what they were talking about - they were terrible at explaining it. Terrible. But the worst part was they obviously looked down on online students. They were all on-campus MEAM (mechanical engineering) students so this is all trivial to them and they constantly made it known, even though they really didn't understand the concepts deeply. This really made the course more difficult than necessary and was demoralizing. The grading on the problem sets and assignments could use some improvement. The weighting of the questions is bizarre and the graders seemed to be hoarding points like gold. I had to go back and forth fighting for regrades and have the TAs be very condescending to finally get the head TA to say ("actually you do have a point - points back"). Ultimately, if they got better TAs, added recitations to explain assignment expectations, and updated their grading rubrics, this would be a favorite course.

This is not a CS course. This is a Mechanical Engineering course where you get to use Python as your calculator. The lectures of this course really don't do a good job explaining what you need to do well in the class. Most of the lecture is just abstract examples with variables and there are not enough or neot good examples for how to approach problems for the problem sets and the labs. It is nice that you can work together with a group, however, the lack of proper lecture matrial to tackle the course content is what makes the class incredibly frustrating. Would not recommend.

The professor is great and TA's are great. It was easier for me because I had a mechanical engineering background, so I was used to the physics nature of the class. Other people might find it difficult. Programming assignments are medium.

I enjoyed aspects of this class, but other parts of it were just frustrating. The lectures were brief with few examples, which made the material more difficult than I think it needed to be. It was definitely made for people with a STEM background. The course uses concepts from trigonometry, calculus, linear algebra, and physics extensively. I had very little training in math or physics, and I survived with some tutoring, but I wouldn't recommend it if that's your background as well. The topics covered were interesting and useful if you want to get into the robotics industry, but it really is just the mathematical foundations of robotics, and not at all how to use programming tools to code a robot's movement. I personally think the latter would have been more useful since there is not a robotics track in our program, and we can't pursue this topic further within our degree.

Things I liked about the class: 1) It gave me a great introduction to blockchains, cryptography and cryptocurrencies, and served as a launching board for me to venture into this rapidly growing space, which is getting more and more news coverage these days. 2) Very manageable workload. It is probably the lightest course of the program. 3) Weekly discussions on current events. It feels more like an ask-me-anything type conversation with Professor Falk, who is very open in sharing his latest research/work/projects. These discussions are in addition to the weekly professor open office hours, and are my favourite part of the course. Do attend them if you can. Things I disliked about the class: 1) One-attempt quizzes. Quizzes make up 20% of the grade, and are questions about the theory/concepts presented in the lectures. To do well in them, you need to have a great level of understanding of the material. 2) Dry lectures. I am probably spoiled by Dr. Farmer's 593 lectures, but most lectures do feel like a read-off of lecture slides. Some concepts were not well-explained in my humble opinion. 3) Less TA support available than core courses. Normal given it is an elective course, and it was not a big factor given most assignments were not too complex. However, most students spent the most time working through the last part of the 5-part final project. Make sure you start early and ask questions on Piazza to get help. Overall, I enjoyed this class and would take it again. This course attempts to cover subjects that are constantly growing - it is not perfect but it does give you the fundamentals. If you are already curious about what's happening in this space, I think this course is a no-brainer.

interesting material, not tough workload for first 10 weeks, 5-7 hours per week, last two projects are tough though bringing it all together at around 20-25hrs per week then. I enjoyed the piazza discussions working through the homeworks and the lecture videos are well done.

Unfortunately this course won't be offered in the future in this format so this review may not be super relevant, but I think the iterations they've done on this course has moved it closer to being worth your time. The first half of the course is actually really well done and an important topic to understand well beyond just crypto. It covers cryptography and distributed consensus, the backbone of the internet, cloud services, etc. I was taking 5550 at the same time and it covered many of the same consensus protocols, though this class covered them more in depth. For that alone I'd recommend this class. Plus, Professor Falk is great, especially in his weekly unstructured industry chats, which were optional but a highlight I'd recommend attending. The crypto portion of the class on the other hand was disappointing. It's really out of date at this point, covers quite a few blockchains that are basically irrelevant now, and at it's core is just kinda thrown together, poorly organized and poorly delivered. If you are interested in the course because of the crypto, don't bother. The assignments throughout are short and pretty easy. Once you get to the final project (which is broken into 5 pieces) things get a little longer, but remain pretty simple, with the exception of the final peice where you actually attempt to connect to blockchain testnets. Then they make you rely much more heavily on public documentation without guidance, and that documentation is poor and in some cases just wrong because the library has been updated/replaced since the assignments were created. But fortunately if you run the starter code with no changes you already get 75/100 so you don't have to worry about that impacting your grade too much. Hopefully when they redesign the course as a half credit course they just cut the second half and focus on the good stuff.

I thought this course was a nice intro to blockchain and cryptography. I did learn a lot, but I'd only take this class if you're specifically interested in blockchain. I found debugging difficult, but I don't think this was really in the hands of the teaching staff because blockchain is so new (for example, testing can be hard because the only way you can test involves spending some crypto). I will say that the lectures can be improved. I found some modules so extraordinarily unclear and it felt like the professors were sometimes mumbling their words. Unfortunately, the one attempt quizzes are based entirely on specific parts of the lecture so I spent a lot of time on those, trying to decipher what the professors meant. Things I liked: - Final project is cool (learn some flask and database stuff) - Nice introduction to vyper Things I wish I were different: - HW coding assignments can be too easy - Current events discussions scheduled right in the middle of the work day - Lectures unclear

This is a poor course that I strongly disliked. It can effectively eradicate your interest in Crypto. Teaching quality is poor. I feel no excitement or passion in his teaching. Office hours got canceled randomly. I'd say if you are interested in Crypto, you might feel better by just reading some books rather than taking this course.

This class is about Blockchains and Cryptography, which as we all know is kinda like the wild west. This class reflects that feeling, it doesn't really feel polished or put together very well. I had frustrations at times with the clarity on homeworks, and with some of the material in lectures. However, I think that the material in this course may end up being some of the most important material that I studied in my entire time at UPenn. The Byzantine Generals problem in and of itself is mind boggling important, and I think this class is a great jumping point to start learning about these technologies. This class is probably at its best if you are already into Blockchains and Crypto and are willing to put a lot of time into side studying. However, if you are like me and knew nothing going in, you will at the very least learn about some really important technology.

I have no idea what the professors are saying. It almost sounds like a stream of consciousness from the way they teach or like a fever dream. The slides say a bunch of technical jargon with no clear connection between any of the specific topics. I can watch like 20 minutes of lectures and feel like i retained absolutely nothing. In fact, i can watch in 30 second intervals, rewind multiple times, and feel like I have no idea what this professor even just said. Good thing the assignments are easy.

This is a great course if you're interested in Blockchains. Granted, I have not done much of my own personal research, but no lecture, course, friend has taught me as well as this course about blockchain, especially the Ethereum, Bitcoin, and Algorand blockchains. I enjoyed learning about hashing, what a blockchain is, and the primary project is to create an exchange (like NYSE) which can exchange Ethereum for Algorand (on their test blockchains). There are interviews and story lecture videos which also paint a good picture of the blockchain universe. Like every course, you can put as much time as you want into each week and assignment. Take the opportunity to ask the professor whatever questions you have about blockchain technology. Blockchains are like the wild west, and there is plenty of (job) opportunity in this arena. My regret is not asking the prof how to setup my own Ethereum wallet--that tells you my level of expertise...

This course sucks. It's easy at least, and until the last few weeks, a really light courseload. The lectures are really hard to understand and offer very few examples that help students understand the material. Honestly, I feel like I didn't really learn much in this class and that's mostly because the lectures were just awful. Don't really recommend this class, but I guess you gotta do what you gotta do.

I've completed all but one required courses for the MCIT program and this course has by far the lightest workload (until the last few weeks) unless you are very keen on diving deep into suggested readings. The TA support was also the lightest I've seen (e.g., office hours was sparse, responses on edstem can take a few days), however it was not a problem until the final project. The material was interesting (especially with recent events) so I am glad I had the opportunity to be exposed to the material. That said, if I were more focused on gaining/practicing programming skills, I would have picked a more intensive course.

Lectures/Textbook/OOH: The course seems to be the in the middle of a re-working, so the lectures are from someone who taught the class two professors ago but are overall pretty good, the textbook was a decent read and could help consolidate some knowledge, but both didn't translate well to the programming assignment homeworks (see below). The professor's office hours, to her credit, were fixed up to be a good source of help on the content after starting off a bit like being tossed in the deep end and expecting us to know how to swim in the content. Programming Assignments: The homeworks are a mix of old and new but all of them need a lot of love to fix their PDF descriptions for what's expected as they are a major source of the difficulty of navigating this class. The lectures and textbook, unfortunately, needed a Rosetta stone to translate from what you read/watch to what you need to do. The advice I got from a TA for translating from Lectures/Textbook to programming assignments, which stunned me, is to look at LeetCode problems and solutions for relevant homework modules. E.g. if the homework is on LinkedLists, go look up LeetCode problems on LinkedLists and review their logic and code to make sense of the textbook and lectures. Don't sleep on M7PA, it is VERY important to have that one wrapped up before the final gauntlet month of Solo > Group > Final (with lectures and quizzes still to do). It is no gimme, and is very important. Keep in mind that M7PA + Projects + Final = 50% of your grade, so that last 5-6 weeks of this class is a true and utter grind. Plan your vacations and daily life accordingly. OHQ/Ed The LeetCode advice from above proved to be a great help paired with Youtube videos and lots of GeeksForGeeks. Especially as, to me, the OHQ availability was often a poor source for help; e.g. TAs not infrequently missing their scheduled times, or completely booked in 5 minutes of opening as (I think) everyone had the same problem of less-than-ideal instructions assignments. Off the top of my head, of the about 12 OHQ sessions I attempted to join: at least 2 didn't have a TA the whole time, 1 I had to wait for after posting on Ed they were missing, 3 I got locked out of the queue (or left hanging), and of the remainder only perhaps 1 did I get an answer during the session. The others which were unanswered I was told I'd hear back after they looked at my code, of which once I got good advice and the rest I never heard from them again. My OHQ experience was a cherry on top of a difficult course for a non-Java dev like myself, as it just made me feel all the more alone in a rough ocean of a course. Ed: This is an active Ed class given the above issues. Read it daily for ideas and knowledge sharing, and then post early and often when you have problems in your assignments so you don't exclusively need to do an OHQ to finish your work. Hours: For weeks 1-6 and 8: 10-20 hours/week, variable depending on how good you are at Java going in (I was/am bad, so the high end). For weeks 7 (M7PA), Solo project, Final project, and Finals: 20-40 hours/week, see above variable. Difficulty: Expect this to be tough going in and it might feel less terrible. Expect it to be the 'cake walk' of previous years and reviews, and it could be a rude awakening. Learning: I gave this a neutral because, despite the sheer chaos it threw into my life, it was counter-weighted by me feeling like I have an immensely better understanding of programming, and programming well, both in Java and generally in this field. The Solo Project, while a slog, got my mind thinking about how objects and classes connect in a way that my brain actually feels re-wired for thinking more programmatically about things. It was a hard fought learning experience which I feel could have been less intense than it was, but I am definitely for the better from it.

This course leave much to be desired. There are weeks where I feel a quick simple coding assignments would allow for better mastery of the topics such as Byzantine Network. The grading for both quiz and coding assignments would do much justice to students with multiple submission considering the instructions and questions sometimes are poorly written or paraphrasing (they do this to create the confusion as not to be word for word to the slides). I feel like Brett Falk lecture videos are more clear and easier to follow with. The course is split 50% cryptography (first 7 weeks) and blockchain (final 7 weeks). Personally, I would prefer much heavier weightage on Blockchain and really get us to start coding Solidity/Vyper smart contracts right after midterm rather than just merely put aside on the final two weeks of the semester with just two sub-assignments. Midterm is fair with being open book because it's applying math/concepts to the problems. The course, despite being rated Easy, should not be curved upward as to penalize students who may have worked meticulously to pass the test cases only to be shot down with few unclear instructions along the way or working with slow Ethereum testnet server for the final assignment causing unconfirmed transactions to pile up.

[1] Interesting concepts. Learned a lot about how cryptography works and the practical usage of blockchain [2] Assignments was hard to understand in terms of what actually needed to be done. I mostly completed them by a bunch of trial-and-error [3] Few final parts of the course were getting way more difficult. Couldn't even complete 1 assignment [4] Quite generous grading

This wasn't a class I was originally planning on taking, but because of the MCITO scheduling, it ended up being my only choice for summer. That said, I enjoyed it more than I thought I would. I particularly enjoyed the section on cryptography - that would be a great topic for a class in and of itself. The blockchain-specific content was interesting and I feel like I have a much better grasp of the existing blockchain structures and processes that are actually out there. Workload was generally light, except for the last part of the final project (which is broken into 5 separate parts, each worth 20% of the final project score). My main gripe with the class is that the wording on quizzes was often unclear - it seemed like close reading skills were being tested rather than comprehension. This also translated to the midterm - I ended up doing multiple regrade requests for questions and explained how the question wording could be misinterpreted (I got all of those points back). Hopefully, they clarify those questions for the next run of the class. Assignments were not difficult once you understood what was expected. I am thankful to all who were able to attend open office hours and clarify quiz and assignment language. I have mixed feelings about the assignment instructions, though: on the one hand, it felt like the bare-bones instructions made the assignments harder than they needed to be; on the other, it made me go out and really figure things out on my own, so I think that I maybe learned more, overall. Up until this point, most classes I have been in hand-hold you through the assignments. This class does not do that, although usually everything you need to know *is* actually in the assignment instructions. My advice for future students is to attend/watch OOH and be proactive about starting assignments early and asking for help on Piazza. Know that most of what you need to know for an assignment is contained in the instructions, even if you don't see it right away. Work hard on each section of the final project - they build on one another, so if you don't get an early part correct, it snowballs into a bigger issue.

While I enjoyed the topics being covered, the teaching quality is disappointing. One of the instructors has lots of room to improve the presentation and teaching skills to make the concept more understandable. YouTube was my best friend to help me understand key concepts, not the lectures. The coding assignments are barely scratching the surface of the topics. More in-depth assignments should be designed to help students learn. I feel like I did not learn much after completing the course.

This was the only MCIT course that I truly disliked. The best thing about 582 is its very light workload. If you have a decent grasp of Python, you could probably get away with spending a couple of hours or so a week on the course, until you get to the final project. And to be honest, it is nice to not be overwhelmed with coursework. But ultimately, the course suffers from too many flaws. The homework is frequently not very rigorous--in most weeks, I wrote less than 20 lines of Python. The homework instructions also tend to be bare-bones, and it often feels like the burden is on the student to figure it out. Finally, quiz and exam questions are often written unclearly, and the hardest part can be figuring out what a question is actually asking. I can't recommend 582 to anyone in good conscience because it was the lowest-quality course that I took in MCIT.

This class was not awesome. It was put together horribly and took a ton of time just to decipher what the instructions were asking for on any given homework assignment. The quizzes are really silly and some, again, are indecipherable.

Worst reviewed course on mcitcentral? Check. Took it anyways? Check. Bad idea, but still got an A? Check. Would take again? No, never in a million years.

Copypasting from my course evaluation in PIT: "I am mightily impressed with the quality of this course. Out of seven MCITO courses I've taken so far, this one is the best. The Exchange Server Project alone made me learn so much new and exciting things I'm seriously considering to follow some of these vectors after graduation to start, for example, writing smart contract all by myself. The best feature of the course, at least to me, is its broad view of the underlying tech. Unlike all other MCIT courses were I was guided by hand, so to speak, this time I was presented with a series of connect-the-dots puzzles that allowed me to choose freely what I am going to learn and how deep should I go. Some of my classmates complain bitterly about a "lack of precise and clearly worded instructions" but I think they confuse leading and trailblazing with blindly following orders. How can anyone call himself or herself a Master of whatever if the person in question can't or won't do extra research on the assignment... After all, life itself is fuzzy and imprecise at best. In all honesty, the course was difficult to me, mostly because I couldn't have enough of it and wanted to learn more, which takes a lot of time. Exchange Server Project alone took me over 120 hours, not because it's inhumanly difficult but because I was developing and testing my code fully locally, which made me a much better user of Linux functionality and utilities not to mention Flask and SQLAlchemy, which I met for the first time in my life. Thanks to 582, now I am knowledgeable enough to deploy a Flask-driven app in the cloud, for example. Not a tiny achievement considering that I was also totally new to Python, to begin with. The cryptography part of the course made me --- finally! --- able to read the books that were way out of my league before I took 582, such as Applied Cryptography by Bruce Schneier, etc. Even the quiz questions that appeared tricky worded at first sight, turned out to be fair and on the point after close examination. Perhaps, the course would become even better if it covered the consensus protocols in more depth. All in all, it's been occasionally bumpy but truly enjoyable ride."

This is the only course I genuinely disliked among all 10 I’ve taken to finish MCIT. Up until the very end, homework is fairly easy if you get it right, but debugging is quite difficult if you get it wrong. On top of that, staffs are generally NOT there. Average response time on Piazza I’d say is a week. My questions were never answered before due date. Slack group for self help was a must. Office hours with TAs weren’t that helpful either. One attempt quizzes make up a decent percentage of the grade, dragging down grade. The very last part of the final project was quite hard to get right. I spent hours debugging trying to get from 70 to 100 and no luck. No help from TAs either. It’s 30 Dec today, and we still haven’t got the letter grade while the last graded item was due on the 13 Dec. Overall poor support from course staffs. You’re on your own if you take this one.

This course struggles to stay on task. The lecture material is poorly aligned with coding assignments, and as others have said before me, support is limited/ documentation is poor. The workload is light, but almost frustratingly light. The only difficult component is the final part of the final project. Getting a 75 on this component takes only a few hours, but getting from a 75 to anything higher is hardly worth the frustration. This is the only course out of the 10 I have taken, that I thought was poorly constructed.

I ended up enjoying this course more than I expected. I feel I have a good understanding of cryptography now, as well as how some of the more popular blockchains actually work at a high-level. My newly acquired knowledge allows me now to state with confidence that some people I’ve met before that talked about "the blockchain" and seemed to be making up stuff about it definitely were :-D 3 other highlights: 1) Slides clearly are updated each semester with updated data (e.g. crypto prices) and new trends (e.g. NFTs). 2) Midterm is open notes (you can even watch Coursera videos during it if you want). 3) No final exam! (just a final project which spans 5 weeks with pre-defined deliverables each week, although the last week took a good 20 hours to figure out, well beyond the normal weekly workload for the course, so try to work ahead a bit in that final project). 3 things to be aware of: 1) The quizzes are tricky, 1-attempt only multiple choice questions that comprise 20% of your grade. 2) It's not an investment class, so while you'll learn the technical details behind a good amount of cryptocurrencies, at best you'll know which crypto technology is appealing to you and which is not, which may or may not mean it's actually worth investing in. 3) Solidity (the most popular programming language for Ethereum smart contracts) is covered at a very high level with no actual practice using it. The 2 smart contract assignments instead are in Vyper, which is the 2nd most popular, and very difficult to debug since you can't print out debug statements. Vyper was chosen because it is a more familiar python-like syntax.

I'm a light programmer in Python so I feel good about the first half of the course. I don't even have to go over the course to complete the homework and also it only takes less than 4hr/w or so. But the second half of the course is horrible to me. I barely know nothing about java and transition of the programming habits from Python to Java was harder than I thought. Normally it took me more time to understand how classes and methods works than really completing the programs and debugging. In this case, I have to say the contents of courses still need to be improved. Or it would be like this, not useful for a-little-experienced programmer and not understandable for completely starters.

I came in with zero experience in coding and found this course to be very difficult. I like that Python was a very good introduction and overall the class is enjoyable. I feel as though the homework is very difficult for what we’re learning for the week though.

If you are someone who has already wrote another language for years(Python and R for me), it would not be a hard class for you.

I think it was a great course (and a great experiment). The Fall 2020 version of this course is, from what I was told, one of the first CIT 591 with both Python and Java usage. Python was generally easy, but then going to Java was quite challenging. The only downside is that the course only covered data structures in Java in like 1 or 2 weeks (while in 593 we had a full 2 months talking about each data structure) and thus for Java newbies creating such structures were a bit challenging, while in Python we can easily create lists/dictionaries/sets/such.

The hours required per week and difficulty level of this intro course can vary a lot depending on your prior programming experience. I did not have much prior experience and found some of the homework assignments to be challenging and time consuming. Guidance from TAs was really helpful and I was impressed with the quality and availability of the TAs in this course. The second half of the class focuses on Java and I found this section to be more difficult than the first half of the class which focuses on Python. I felt outside supplemental resources were valuable for explaining object-oriented programming concepts more clearly than the lectures. Overall, even if you don't have much prior coding experience, if you put in the time and effort and go to office hours to ask questions, it's possible to do well in this class.

Great intro to programming (had never formally coded before). Would be more challenging if I didn't have more detailed Excel experience. Good textbook, good lectures, projects were challenging but not impossibly so. Recitations were critical for success.

Loved this class! I came in with some light programming experience, but not in either of the languages covered in class. Python is so intuitive, it's a breath of fresh air if you're moving from more intense languages (I've only ever done a bit of C). The homework assignments were a lot of fun, and weren't too challenging. I thought the midterm was very easy, but struggled a bit on the final. Just because the final is open-book doesn't mean it's going to be easy!! The class itself seemed well structured, and I liked the way material was organized. I think this is a great introductory course to the program

A moderately light course to introduce students to software engineering in the MCIT program. First half covers Python while second half covers Java. Homework is fun but education. Of the homework assignments, the first 7 are solo projects while are last 2 can be done in collaboration with a partner. Grading is fair. The midterm and the final are take-home exams, and we are given more than enough time to complete them over the span of a few days. Overall well organised video lectures. I have found the recitation and open office hours to be very useful. Instructor is very approachable too.

Excellent introduction to programming course. I have previous programming experience so I did not find the assignments too hard, however, I can see why someone who has never programmed before can be overwhelmed a little by the projects. Great instructor and great depth of material covered.

591 is a good introduction to both Python and Java, but unfortunately lacks depth in both. The assignments were both challenging and fun, particularly towards the end of the semester. It's easy to do well in this class just doing the minimum (quizzes and assignments), but the optional practice opportunities are a great way to get more out of the class. Assignments are bi-weekly and took me around 10 hours each.

The assignments are fun, but the course is ineffective at teaching the material. The first half of the course is done in python, which I had a bit of a background in so it was not that hard, but the second half is in Java where we moved way too quickly through the material and the lessons were not great at helping students understand the material.

CIT 591 is extremely well designed and supported by the course staffs. From professor, to head TA, to the entire TA Teams, the course staffs are fantastic. They offer tremendous support for the students. The assignments are designed perfectly, which enable students to further enhance coding skills and design skills. Most of the TA Teams are so knowledgable and helpful. I learned a lot from the private office hours. The only potential advice is that midterm and final can be organized in a more challenging way, for instance, placing a time constraint or making it closed book. The current open book take home offers great flexibility, but a little bit too easy compared to the difficulty level of the assignments.

Provided a great intro to a lot of topics with excellent assignments that really solidified the information. The course content, however, lacked context when introducing new concepts so the lectures themselves were abstract until you got to the assignments.Be ware of the autograder. It's a black box that has a major impact on grades and causes lots of frustration especially when passing all the provided unit tests and getting high marks from the TA. For your assignments, ask lots of questions about discrepancies between the TA grade and the autograder grade so you can develop a better intuition for how they craft the auto grader unit tests. Ultimately, this is something that needs to be addressed because it flies in the face of good unit testing practices, isn't reflective of how unit testing works in the real world, and doesn't provide a chance to learn why you're failing automated tests but still meeting the assignment requirements.

I love this course. I have 0 background in Java, which makes the course a bit harder. But I really enjoyed it and the lectures are well prepared. The TAs are almost always helpful. Thank you everyone for making this course great.

In retrospect this class was very decent (I am writing this in reflection upon graduating). Starting out in the program, this class is a very good introduction to "this is how stem classes work", and programming of course. I learned to be extremely detail oriented, test for every possible case, and to build stamina in preparation for exams. I remember being very overwhelmed taking this as my first class in the program while working full-time. 3 years later, I would say I am now just used to working weekends and nights to finish assignments and it doesn't feel nearly as terrifying and stressful as it did that first semester. If you have concerns, they are valid. Have a good support system, meal prep, schedule your time. You can do this!

The Java portion of the class is definitely trickier than the Python section and the assignments get longer towards the end. But the grading is fair and it was a great intro to both languages.

The second half (Java) might be little bit challenging for those get used to the hassle-free Python

I came into this course having taken several MOOC's in the Python Programming Language and one MOOC in Object Oriented Programming with Java. While I was still exposed to new ideas and mindsets through this course, I believe this prior preparation made the course very easy. There were a few projects that ate up a lot of time (15 - 20 hours or so a piece) but by and large the content was digestible within a couple hours each week. For those interested in MCIT Online, and curious what MOOC's might be good to try on your path to this program, I completed the following MOOC's in the order listed: 1)Python for Everyone Specialization - Coursera - University of Michigan - Professor is Fantastic. 2)Python 3 Programming Specialization - Coursera - University of Michigan - Good Foundation. 3)Introduction to Computer Science and Programming Using Python - edX - MITX - Very Rigorous. 4)Object Oriented Programming in Java Specialization - Coursera - Duke University - Great Foundation.

I came into the course with a bit of prior programming knowledge and found the course to be relatively easy. However, I do agree with many others that the course material is lacking for those with little programming experience. For people taking the course in the future, it might be a good idea to take another introductory programming MOOC just to gain some familiarity with basic programming so that the course won't be too overwhelming.

The first half of the course is taught in Python and the second half in Java. My only experience with programming was from a couple months before classes began when I learned a bit of Python on my own. This helped me tremendously in the first half of the semester where I didn't have to spend much time learning new materials and just used my prior knowledge to do the assignments. If I had not learned Python beforehand, I'd say the learning curve would've been quite steep. There's a big leap from week to week, and I don't think the course materials were adequate. The midterm was in Python only and was take home so there was little stress. I started struggling a bit more when we started learning Java just because I've had zero experience with it. I ended up purchasing a Java class on Udemy which helped me get up to speed. The content provided by this class was again insufficient. They barely scratch the surface and rarely explain to students the "why". Definitely expect to look for outside resources when taking this class. It just seems so ironic that I learned all my programming through a $10 Udemy course rather than the $2500 class I paid for. The final exam was open book and on Java only, but due to bad integration of VS Code and Codio, I know many students had terrible technical issues (luckily I took it on the last day so most issues were ironed out by then). We couldn't even set breakpoints for most of our code though so it was back to print statements for debugging which was painful. I hope the technical issues get resolved for future semesters. I'm not saying the class was all that bad though. I thought the assignments were fun and the overall structure of a proper class have really motivated me to learn. The prof seems like a really nice guy and he is really willing to help during his office hours, which usually go for almost 2 hours. The TAs were also very helpful. I think there's a lot of room for improvement, and improvement takes time!

It is effective at teaching you Python and Java. The assignments are pretty clear and serve as great practice for getting comfortable programming. They can become time consuming if you get stuck debugging, or if you go into the assignment without a good understanding of what you need to do. With that said, the grading is pretty generous, and the exams tend to be easier than the homework assignments.

This is a fantastic class, and Brandon is a fantastic instructor. Yes, you start fast and furious with Python in the first term and Java in the second, but the course structure and the quality of the instruction/projects makes it quite enjoyable. This is my weekly breath of fresh air after 592.

Overall a fantastic introduction to software development - well taught, well graded, and well paced. Coming in with some coding experience certainly made the earlier half easier, but at a certain point, the assignments become more robust and time-intensive. Plus, Java classes require you to think a bit differently. The problems may not always prove logically difficult, but the sheer practice and repetition even made the more seasoned developers better. Especially with the framework of most code already provided, it becomes more of a fill-in-the blanks practice. No regrets for me whatsoever.

I took advantage of the preview weeks for this course and found the course load very manageable until the very end of the course. I was a novice to programming at the onset of this course and left comfortable with the ability to pick up new programming languages in the future.

591 is a great introductory course to programming in Python and Java. The assignments were clearly written and the TA support staff is very robust. If you have programmed before, this class is straightforward! If you haven't programmed before, I would recommend learning a little bit of coding before class starts. For people completely new to coding, the class moves at a somewhat fast pace. The Java portion can be daunting if you are unfamiliar to OOP languages. Overall, this was a great class with fun assignments too!

Excellent content and instructor. Very much enjoyed the assignments. My biggest advice would be to not simply skim through the lectures. Make sure you understand the content.

Awesome and fun class. It's hard to judge how much time this class takes, some weeks are very light, some took me over 15h.

Brandon is nice.

I believe since this is the first course it seems like most reviews depend on the amount of programming experience the student has prior to the course. for me, I just had the MOOC problem solving and some python experience from Udemy. I had really put in the efforts and clocked about 25 hrs per week, and went deep on learning the intricacies of setting up IDEs and everything on the lectures. after all I believe it depends on what you put in for the results to show. I would recommend attending the intstructor office hours, The professor in Fall 2021(I am not sure if we are allowed to mention names here but he is pretty much the only one teaching the course until now) is super awesome. and often the professor's office hours have only 12-20 students attending at least for my cohort. Which is amazing it is even better than an in-person class to get that kind of face time. The professor is amazing at keeping everyone on pace, and taking all kinds of questions. Especially after the second half of the course, it gets better since the ones attending are pretty much sticking with it. I am glad I did not try to waive out of it, and I gained a solid base for CIT-5940, also another excellent class with another big brains professor, and amazing welcoming office hours. I highly recommend jumping and experimenting with your own ideas based on the course.

I've never coded before this class. I found the lecture content lacked any kind of grounding background information. The learn by doing didn't work for me because I wasn't equipped with all the tools I needed to succeed. There was little information about how to actually think about and solve the problems we were asked to do in our homework, and the grading feedback was infuriatingly sparse. I don't feel equipped to code successfully in other classes, and I worry about my ability to succeed in this degree because of the lack of support. The professor is good. But some of the TAs and their lack of feedback makes it near impossible to know what you did wrong or how to improve. Thankfully, I didn't fail the class, but I wish they'd make this more accessible to absolute beginners. And don't get me started on ProctorU.

I came into this course with some Python experience and a background in Control System Programming. Overall the course was easy with my background. The homework varied in complexity and some required substantially more time than others. On average it was probably 10 hours or less per week (I believe one homework took around 20hours but we had multiple weeks to complete that homework). Starting the homework as early as possible is helpful. This class did not require any external resources. Creating your own cheat sheet while going through the lectures is helpful as you then have a nice quick reference to look at once you complete the course.

For context, I had taken introductory programming classes in college a few years ago and come from a mechanical engineering background. I really liked the introduction to Python. It's perfect as a first experience and provides the basic knowledge needed to further learn it by yourself once the course is done. In the middle of the semester there was a switch to Java which I didn't find extremely hard (the teacher provides the starter code and, with some observation, you can find your way around it). Assignments were medium difficulty, except one in the first half and the last two, but with office hour help they should be doable. Start early in the week. You can also drop your worst graded assignment so it's not considered for your final grade. I think the course was curved at the end as well.

Course difficulty is a bit subjective, however generally I think if you have any bit of programming experience (ex: took a class many years ago, etc...) the course won't be too difficult. However, regardless of background, the course is rewarding in helping one get acclimated to coding. Assignments were where most of my learning occurred as lecture videos were not too helpful. Lectures were simply too short and explanations sometimes lacking. Pacing was also a bit of an issue, as the jump from Python to the Pandas library to Java can be a bit much to handle if you don't have some prior experience in the latter two. In the end though, learning to program is really about getting reps in, so spending the time to do optional ungraded assignments was helpful for understanding concepts.

The last two weeks were much harder than the rest of the course. The final was much harder than the rest of the course. I loved it, learned a lot.

Even with 0 experence in programming, this course was way too easy. Not enough coding practices and 30 seconds lecture videos.

I really liked the first half of the course in which we did Python. It was just challenging enough to be accessible. However, the Java portion was a surprise, and I felt like the videos did not present the materials we were supposed to know in detail enough and that the assignments went beyond the level taught in the videos. Tips for future students: Brush up on both Python and especially Java, and use a lot of supplemental resources for the Java portion.

If you have any prior experience in programming then this class will likely be a breeze. I took an introductory CS course previously and found 591 to be lacking in comparison. The lectures were mostly the professor reading off of slides and rarely went beyond definitions of concepts. These were followed by quite long example projects which weren't always the most helpful. While the Python section of the course was fine for the most part, Java was pretty unsatisfactory. Crucial OOP principles like encapsulation or polymorphism were brushed over and very little detail or explanation was given. Overall, the focus was more on Java syntax rather than good programming practices, and I feel like this is not the best way to set a good foundation for new computer scientists. The homework projects were pretty fun to work on for the most part, but many were quite long and it's questionable how useful they were as pedagogical tools. If you are new to programming and taking this class, I strongly recommend getting a textbook to supplement the Java sections in this course. It will likely explain concepts much more deeply and will give a lot more details do parts that were insufficiently covered in 591 but crucial to know. With that said, I do give credit to the professor and TAs for being very helpful in office hours, recitations, and Piazza. Definitely use all of the resources available to you if you have questions. If the course were more detailed was designed better overall, it has the potential to be a solid introduction to programming.

This is a solid course. Very good introduction to programming. They cover all the fundamentals, from lists to object-oriented programming and connecting to databases. Overall I was pretty satisfied. The assignments take some time. I just feel some assignments require techniques that were not fully explained in the lectures, so we end up doing more research than we should. But that is a minor complaint. The course was pretty good.

Good introduction to oop. If you’ve had prior experience it may feel slow but if not it’s a very well thought out introductory course.

I came to this course with zero coding experience before, and found very comfortable to follow the pace of this course. No supplement learning materials is required for Python part. However, I do need to find some Youtube videos for the Java part to help me understand the materials better, especially some abstract concepts. Homework can be a bit challenge at first but it's not too hard. They are great to help consolidate the knowledge learnt in lecture. I didn't have time to go through all practice assignment (non-graded) since I am working full-time but they are also really well prepared. I didn't go to office hour or recitations often because I like trial and errors when it comes to programming (like if I only look at the coding example then I wouldn't feel like my brain is absorbing the information). But they do give demo or hint for HW so it's good to check out if you got stuck on HW. TAs are also nice and helpful.

Note: I had significant python experience, and very limited java experience before starting this course. The first half of this course is python which I would say is very easy. The assignments take only an hour or two per week and the lectures are things you can find just by reading python documentation. What I wish is that they had covered OOP in python since I feel like it is an important concept to grasp. If you have no prior coding experience I think this is a good intro as it goes over some important primitive data structures and give simple applications of them, but it may take you 2-8 hours per week to do the homework. There is a midterm project in python which was almost exactly like the practice they give you to do and was really straight forward. The second half of the course is java. You start learning the basic java syntax as well as OOP. The course gets a little harder at this point and the last two homework assignments can take significant time since they are much larger applications of what you have learned, so start those early. I would say overall it was a good intro to python/java and provides basic understanding of how the language works for all skill levels. At the end of this course you would definitely be able to code basic programs (likely inefficiently), and will probably not fully understand how to apply OOP to system design.

This is a review of 591 coming from someone who knew Python very well but not inheritance or Java, so your mileage may vary. Resources were widely available through code examples from the lectures as well as using docs on the web for language/method specific help. The TA's were helpful on EdStem to address anything relating logistics or setting up coding environments and IDE's. The lecture quality was similar to the MOOC specialization and were short videos that showed basic examples of how concepts were applied in the course to certain scripts. However, for someone new, it can be overwhelming relying on the lectures alone. Therefore, make sure to make some time to research on YouTube if you are completely new to programming. Assignments and exams were very straight forward as the specs and template code they give you is very easy to follow. For someone new, some of the later assignments can be daunting at first, but are easier to approach once you plan it out via drawing/debugging your code output. A lot of the boilerplate code makes inserting the methods you code on your own very simple to run. One thing I found very helpful in the course was Test Driven Development. A lot of engineers I know in tech had an intro course in programming, but all the test cases were written for them. This doesn't help later in classes such as Data Structures and Algorithms where you need to test the data structures you implement. Therefore, I thought that was a great part of the course! Overall, I think that the course was well designed from the perspective of someone who already knew some programming,

First of all, since I have no programming experience, I am fully aware that I will need to spend additional efforts to learn this intro course. But the course content and the materials are not as helpful as the other MOCC (free online course resource) I found online. Especially when I found out that the Java part of the course content is identically the same as another course from Udemy, I have not been clicking on those links from 591 anymore. (Not gonna lie, even the course examples are the same examples from the Udemy course, but 591 is a 20% subset of that course). Brandon and our TAs are the reason why I give a Neutral rating. TAs are always responsive from Piazza, and Brandon usually willing to stay longer during the office hour to ensure all the student's questions got an answer.

I'm someone who came into the program with limited programming knowledge (my degree was in literarature and business, but I took some introduction Python courses before applying to MCIT). Honestly, the homework were my favorite part of this course. They aren't too hard, but definitely pushed students to learn more than what the course materials delivered. By saying that, I meant most of the codes are not directly derivable from the slides, and the predetermined stubs given by the instructor have not been clear in what and how functions should interact with each other. Every homework has such great leap from the prior one and I can see someone who's completely new to the language spending over 20 hours trying to learn a new concept that's not properly delivered by the slides/lecturer reading off the slides. With all being commented on the course, I understand that the lecturer Brandon is new to this course, and he and TAs are indeed very dedicated to 591 if you notice his public official hour recordings are normally over the 60 minutes guideline. He actually put in a lot of efforts providing students with what they need to learn. However, as the whole idea of oMCIT was for students being free to learn the course content under all conditions, I know there are a lot of folks who aren't able to attend to every recitation and office hours, which put them into a less advantaged position. For me, I feel that there are 3 homework that takes more time but most of the time outside of homework I did end up spending less than 5 hours per week on this course. To sum up, 591 is an introduction course so maybe it is why most of the course was on the easy side. But if someone comes in with 0 background, he/she will not be able to finish the homework and practice assignments without referring to material outside of the class. The homework projects were fun and the course support was phenomenal, but the course is due for a completeness review and maybe supplementing additional texts and codes demos rather than keeping the current 15-20 second videos that just reads off the slides. It's purely waste of time and I'd rather just read the slides myself.

This class covered a lot, but the material was not that well-structured. Several times the homework assignments required extra knowledges that was not being taught at the time but would be taught in the coming one or two weeks. But I still really like the assignments. They were pretty challenging and each of them can take you to the next level. However, I think the amount of workload was not consistent and was reduced to some degree during the second half of the course.

For those who have zero to little coding background like me, this is a good introductory course. The lecture videos, practice coding assignments are good and enough to prepare for the exams (which I think was fair in terms of difficulty). Attempt all the homework assignments and as much as possible, apply best coding practices in your submissions (not just coding for the sake of passing the grading rubric) - ask Prof. Brandon and the TAs for help. I have taken advantage of private OH, piazza, and make time to attend the instructor OH twice a week. If you feel that you have enough OOP knowledge, take a waiver exam instead. Otherwise, this course is designed for those with zero to minimal coding background.

I came into this course with some prior experience so was relatively easy. But if you have never coded before it will require you plenty of time to get accustomed to the syntax first of Python then of Java. The course is well structured and does its job of introducing you to software engineering.

It was a good introduction course to programming. As long as you spend decent amount of time each week and practice the assignments and homework in a timely manner you should be able to do well. The course is well-rounded, I personally did minimal additional reading to supplement my knowledge and pass the course. But, for someone hasn't programmed before it might be good idea to pair the coursework with a standard textbook in python and Java.

I really enjoyed this course. I love the breadth of material covered, I thought the workload was very reasonable, and I thought the general approach to grading and evaluation was really fair. You have to take this course, so you're going to, but I bet you'll enjoy it a lot.

Great introduction to programming and the MCIT program. Projects were challenging, but manageable. Final project allowed students to work at there level and incorporate prior coding experience.

I enjoyed this course and thought it was straightforward. The workload varies significantly week to week, and in particular the final few assignments took a lot of time to finish. If you have no prior experience programming I would suggest getting one of the recommended textbooks, especially for the Java section - I took Java in undergrad a few years ago and I had to refer back to my notes to better understand some things. The midterm and final both had optional practice assignments; I’d recommend completing these as they helped a lot for the actual midterm and final. Instructor office hours and recitations also were great for giving hints and elaborating on assignments.

Overall the course was fine, but I felt like it wasn't quite sure what it wants to be when it grows up. While it is nice to cover both Python and Java for the sake of awareness, I think that we could have gone far more in-depth with "Software Development" and Computer Science by simply focusing on one of the two languages and going further in depth with it, building something neat and worthwhile. If the purpose of covering Python was to establish some core concepts in programming, this was unnecessary. If the purpose was to give us a baseline in Python, this was inadequate (I would estimate that half of the students already knew what was covered with Python, as it was very basic). Important concepts like version control and databases were only given minor attention in what seemed like more of an afterthought. Unit Testing, while arguably important, received far more attention (and required far more time) than necessary, and we could have used that time to explore additional concepts. At the end of the course, I was left asking, "What exactly was the overall goal of this course?" Was it to be able to write unit tests and javadocs blindfolded? Or, was it to survey all of the fundamental concepts of software development? Or, was it to get good enough in a language to say, "I know this language." The homework assignments tended to be somewhat rigid in what the final outcome was supposed to look like, and this is because most everything is auto-graded. Auto-grading for a $100 MOOC is fine, but for a $2500+ course, I would expect a bit more of a tailored approach, a bit more hands-on work from the TA's. Lastly, this course left us without any portfolio-building projects. I would have much rather had a "Intro to Software Development with Java" course so that we had time and depth to build something real-world, instead of a regurgitation of many of the concepts covered in the free computational thinking prep course.

Coming to this course with a fair amount of experience in Java and some experience in Python, I did not learn as much as I hoped to. I did enjoy the assignments and felt that I got some valuable experience working on them, but I found that the areas of the course that were new to me (like the data analysis with Python section) were confusing and I relied more on external resources to figure them out than I hoped to. Professor office hours and TAs were very helpful in general though! I appreciated the lighter workload as well.

Coming from Python going into this course none of the concepts were new to me. Though I still spent in total probably 15-20 hrs/week, but that's because I like to go slow. Material presented clearly and content was well-organized. Easily digestible and all the info was on the slides which is nice if you want to skip videos. I liked the assignments and thought they were the perfect intensity. Intro level course, nuff said. My 2 cents: I took a Udemy course on Python and enjoyed it more. I would have liked the material (both Python & Java) to be presented in a less prescribed "read off the slide" manner, make it a bit more fun or interesting. I think an intro-level course needs that. But, most universities teach the way they do so nothing against MCIT there!

This class is incredibly organized. For those who say it's hard - there are PLENTY of resources for you to succeed. If you find it harder, there are practice projects available every week. I found that I did them early on, and then sort of stopped once I became more comfortable. Some homework's will take you 20 hours, some will take 6. Really depends! Professor Brandon is AMAZING - his instructor OH are super awesome to attend (even for the conversation). TA OH will be critical for succeeding if you are struggling understanding the concepts of coding and how to approach certain things. Also, Piazza is an amazing resource. Students help eachother out all the time and post helpful answers! One thing I would keep in mind to succeed - learn how to debug. Early. Just look up some youtube videos on it. Try to figure things out yourself first before attending office hours. Lastly, remember that looking at someone else's code and trying to find a problem is HARD! Show the TAs grace. That isn't easy for anybody. Also... a hw is dropped, so if you are feeling super stressed and don't have time, take advantage and skip an assignment!

You pay 3k dollars for a course. What you got is far less than a free Codecademy course.

I had previous Java and Python experience, so the material wasn't exactly new and weekly workloads were minimal. I gave this a maximal rating from personal experience -- I thought it was a good overall view of programming. That said, if you're a beginner, as in someone with NO previous experience, I would expect to spend 10-15 hours per week on average for the class. Some weeks are light, with only quizzes. Other weeks have full-fledged assignments that will take you 4-8 hours alone, not including lectures.

I came in with a background in mechanical engineering (some Python experience, no Java experience) and this course wasn't too bad. The first half in Python is fairly straightforward, but the difficulty and potential for confusion increases in the second half of the course with Java. However, Brandon and the TAs are very helpful in assisting with questions through Piazza (I didn't go to any OH). The lecture videos for this course are excellent. I highly recommend coding along with each and every one of the "code demos" in the lectures. I would watch Brandon write a few lines and then write them myself, run them, play around with them, and only move on when I felt I fully understood what he did and why he did it. Getting through the lectures takes much longer this way, but I felt like I didn't need to do most of the practice assignments before hitting the homework. Homework is due every 1-2 weeks depending on the size of the homework. Every homework felt fair since all concepts are always covered in lectures. The last two homework assignments can be done with a teammate but are completely possible to do one your own with maybe 25% more time.

I have learned Python before but I'm a total novice when it comes to Java. That's why I didn't even try to waive this course as I thought that 591 could lay a firm foundation of Java for me. But I was wrong. It only scratched the surface of Java and the short videos (40s) are really not conducive to learning. Brandon is a very nice guy but he is not a Python coder as his demo code is not pythonic. Honestly, 591 did not meet my expectation of Penn. And if you have coding background, definitely try to waive this course.

This is a great course overall. However, having very limited programming background, I found it challenging. I would say I probably averaged more hours/week than most as I double/triple checked a lot of my assignments and tried various ways to break my code. Great overall structure with the opportunity to learn a lot. The second half of the course (java) was harder and required more time for me, particularly as I knew some python (covered in the first half of the course) going into this class. Watch the recitations when you can to help you better understand concepts. I watched them a couple days after and was able to speed them up and save some time. The TAs and professor were extremely helpful.

Pretty easy with prior software engineering experience. I didn't learn many new concepts, just syntax for Java and Python.Toward the end of the course homework assignments get more time consuming, but everybody's lowest hw grade was dropped. I can imagine that if you don't have programming experience though, this would be a very difficult, fast-paced course.

Like a lot of incoming MCIT students, I had a good amount of experience with Python before this course, but none with Java. That made the first half of the course pretty straightforward and easy, but the second half tougher (still not very tough, but it definitely took more time). If someone came into the program with literally zero programming experience, though, I could see this being much more difficult and time consuming.

I came into the course being comfortable with Python but knew nothing about Java. I really liked the course and its structure. It's a great foundational course! It lets you practice a lot of concepts. Homeworks are fairly asking to practice what was taught. The teaching team is quite good and the professor is really knowledgeable and very responsive. The final is a bit trippy with VSCode. Practice it early in the Java section and make sure to do a practice exam.

I think it is important to say this as 591 is the first course in the program. If you come from 0 programming background you can survive this program, not only that but you can thrive. You need to estimate how quick of a learner you are. This course can take 10-20 hours. I spent about 3-4 hours on content and practices, with 8 hours per assignment almost every week. The midterm is generally some of the higher grades in the course and is good to see as even if you struggle at first, most people do very well in this course. Since its an intro course it has the most TAs, TLPs, and graders of any course. Which is very helpful for questions.

Relatively easy if you come into the class with basic exposure to Python and Java, otherwise, I can imagine there being a steeper learning curve. I appreciate the broad range of content covered in the class but I did not like that the lectures tended to tell us how to write code rather than why we design code in a certain way (to be fair, it was not totally neglected but I felt that the course could have done a much better job at this).

Came into the class with no prior programming experience and found the course very fulfilling and challenging. Between watching the lectures and working on the programming assignments, I spent 25-30 hours most weeks on this course (and enjoyed every minute of it)

I came into this course having completed a couple programming bootcamps but no professional experience. I found the course easy and not very time-consuming. I knew Python already but learned Java in class, so naturally I had to spend more time once we reached the Java portion of the class. Still, I learned a fair amount and feel I can write code more cleanly and deliberately after taking this course. Professor explains very well. Homeworks have a very clearly stated rubric, so you know exactly what to expect. If your code matches the expectations, you will get full marks on the homework, so the path to an A is straightforward.

I found the class to be highly manageable. Java was a lot more challenging than Python for me but the course structure sets you up for success. I feel very proud of the programs I developed! I averaged 12/hrs per week but you can go way over that if you do every practice assignment. One homework is dropped and I ended up giving a partial submission to the last homework as I had fallen a bit behind due to work and a trip I took around the same time. I'm reviewing this course as medium difficulty with the caveat that it's the only course I've taken so far through MCIT.

-I took this course in Spring 2020 (all Java). I didn't have much programming experience before taking it. -The good: I appreciated the assignments, which were very challenging for me. -What didn't work for me: I'm not a fan of learning to code from videos (too passive), so that was a bit of a struggle. My main criticism is that the class seemed to be under-resourced. There wasn't much synchronous TA support. (Sometimes Piazza just isn't the best venue.) If you wanted a 15-minute office hour slot with a TA, you'd have to book 2 weeks in advance (if you were lucky even to get a slot), and of course, it was impossible to know whether you were going to need help at that point. (They offered an hour or two of drop-in office hours a few days before a few of the projects, but no other drop-in support was offered.) This is even though TAs were paid very little, and even though the class size (and budget, I'm guessing) was quite large. This was a big weakness for an introductory course, IMHO. After having taken other classes (especially 593 and 595), I've realized that it actually IS possible to have substantive synchronous help from TAs, which would have made a huge difference for me in an introductory class. I suffered in silence so much, and honestly, if it hadn't been for my minimal previous experience with coding, I'm not sure I would have stuck with it. I'm hoping this is better now!

I was a bit surprised and perhaps disappointed when the lecture content for this course ended up being less than a minute in length for some videos and often didn't provide very much information, but as I took the course and looking at it retrospectively I don't think it hindered my learning capabilities in any way. In fact, I feel if there were long, drawn out lectures where we watch prof or a TA code I would probably zone out and not take away much from it. The real learning comes from diving into the project assignments and figuring out how coding works. What does the formatting look like? What is a variable? How do I create an algorithm? and so on. I liked that the course started off with Python, one of the arguably easier languages to begin with, but found the transition from Python to Java a bit painful. I felt lost during the second half of the course and struggled harder to keep my performance up. By the end of the course I felt like I didn't learn much of Java. Once I got into 594 I was shocked to have a completely different experience and felt like I had been writing in Java for years. I must have picked up more Java than I had realized when taking 591.

If you are completely new to coding, it be might be challenging to grasp all the new concepts and syntax. Optionally, I recommend you skim through the Python and Java Tutorial on w3schools.com prior to starting the class. It will be great practice transition into MCIT.

If you have any previous coding experience, this course will most likely be very easy for you. I enjoyed learning about object-oriented concepts in the Java portion (second half) of the course. I do think that using two languages in the course is probably a mistake -- just as the students who haven't coded before start to get comfortable with Python syntax, they're asked to switch languages. It's hard to internalize concepts and learn general patterns when you're bogged down in syntax.

Excellent class. I had some knowledge of programming coming into the program but this class, especially the last few projects, really help you learn how to put it all together.

Good intro course. Most of the assignments were pretty straightforward and didn't take too much time. A couple homework assignments at the end of the semester were more involved.

Overall, a great intro to computer programming. This said, having talked to other MCIT students who enrolled earlier and some friends in the field, trying to cram Java in for half the semester was tough to wade through. Ideally, I'd love a 0.5 credit for Python and a 0.5 credit for 'Thinking like a computer scientist', or making them pre-requisites on Coursera, prior to diving into Java for a full semester where it could breathe a bit. That said, the semester as it is was still a great start to programming and I feel like I learned an immense amount in a short amount of time. I HIGHLY recommend doing the Coursera Python and Java courses from the same professor, it can make your life much easier. And do all the practice assignments, it's worth it. Be ready to check out sites like GeeksForGeeks for deeper understanding of topics gone over in class.

TL;DR: This class is fantastic! It covers many immediately-useful concepts to propel a complete beginner to a functional programmer. If you already have programming experience, it's an easy class. The first half covered Python, but in a way that's suitable for absolute beginners. After the basics, we covered important topics like file import/export and data parsing. I was already familiar with coding, so the Python module was a breeze. Python midterm was an open-book take-home exam. The second half covers Java. In my case, I already had experience with object-oriented programming (OOP) through C++, so I had minimal difficulty with the concept of OOP and Java syntax. However, for a beginner, it can be quite a left turn and the course covers a lot of material, fast. The focus was on teaching functionally useful concepts, such as Collections and RegEx. Final exam was not easy, but partly because we had to use VSCode through Codio, which was clunky to say the least. My advice to anyone taking this course: Do ALL the assignments even if they're optional and don't explicitly count towards your grade - they helped me hone my programmatic thinking and become comfortable with syntax and useful object methods.

Generally, I find the course to be a very good introduction to programming. I like the professional organization of the course. They really deliver what they announce. Exams are easier than the homework assignments. Personally, I have been programming in my job and academics since a couple of years (Python and others, but no Java). Yet, I never received any formal education on programming which I was looking mostly forward to in this course. And indeed, I received some of it (unit testing, abstraction, and assignment by reference are crossing my mind). But was it worth the time and the money spent? Maybe I should have given the waiver exam a go and accepted a bumpier start in more advanced (Java-based) modules.

@ Beginning coders - do not be fooled by the overall rating for this course. You will be surprised by how many people in this program actually have prior experience in programming, and more often than not these prior coders will be the ones who are active on Ed. Don't let this discourage you! You're not alone. Just be aware that the lectures are very easy but do nowhere near enough to prepare you for the assignments. The midterm on the other hand was much easier.

This class was a great introduction to programming for me. It was very difficult but also very satisfying and a valuable experience

The course moves fast and the homework assignments can be challenging, so start on them early. If this is your first exposure to programing, I recommend taking Python and Java MOOCs and/or reading the recommended books before the semester starts. The lectures are short videos and do not cover the difficulty of the assignments. Use the recitations, office hours, piazza and optional assignments to fill in the gaps. The TAs are an incredible resource. The midterm and final are not difficult if you understand the material.

I came in with little coding experience(completed the majority of Harvard's CS50). The python part of the course seemed well developed, the Java part seemed less so. I learned a lot since I don't have much experience. Earmarking 15 hours a week for this course, did well for me. In addition, having the expectation that the hw appears hard at first, and then gets better, and achievable to finish. I appreciate that deadlines were moved back, when it appeared the class was having a difficult time with the homework. In addition, a dropped homework and curve.

This course is fair and if you study the homework and practice problems, you should be fine for the exam.

In my opinion the best out of the first three core courses, extremely well structured and well taught. Very good and thorough explanations in the lecture videos and during recitations. Exercises work very well in deepening the understanding of the lecture material. Difficulty of the course is subjective, if you have some undergrad background in maths the material will be easy to grasp. The only negative aspect was the quality of the exercise's grading, it often felt like the graders (not the TAs!) had no clue what they were actually doing. But well-reasoned regrade requests were usually accepted.

this course felt like eating vegetables for me, not necessarily designed to be enjoyable for students but probably required for success in the program.

With math being my least favourite subject in school, I came into the course knowing that it would be really challenging for me, and it was. The course is split into 3 sections, first on some basic terminologies, counting, functions etc. second on probability, and third on graph theory. I struggled a lot during the first section of the class where I felt that a lot of terminologies were introduced without proper explanation. Some sections of the course material were so concise that I could not figure out how we got to the end result. I had to watch many Youtube videos to supplement my learning and grasp the concepts. I did a lot better in probability and graph theory however, perhaps because I got used to the flow of this class and the first section set me up well. There were 3 non-cumulative timed assignments, and I found them to be quite fair. The recitations and prof office hours are must-attends. Recitations go over additional problems which helped me a lot with the assignments. Prof office hours go over any questions students may have, which were typically directly related to the assignment for that week. TAs and prof were fantastic. I just wish the materials (Coursera videos) were elaborated upon more, knowing that there are a lot of people without a quantitative background taking this class. Overall I felt like I learned a lot so no regrets!

592 felt like a clean slate especially for someone who struggled with math in the past. Perhaps it's due to never having spent so much time on math before, but I thought the course overall felt rewarding. The problem sets were challenging, and sometimes harshly graded (as were the exams), but I think one should embrace that rather than not. It forced me to re-evaluate my own logic and ability to reason, which definitely has improved compared to before taking the course. You really need to understand the concepts thoroughly as making mistakes can be costly. The course can both be frustrating at times but also rewarding. I can tangibly say I learnt a lot. My only gripe is that I thought lectures could be improved. As there's a wide variety of backgrounds that students are coming from, I could see some benefiting from lectures that specifically reinforce some key concepts. I see the need for students to be taught a more traditional college math class/approach, especially with 596 awaiting, but I sometimes found lectures unnecessarily difficult to understand. Though, admittingly, I also can see a counterargument being to avoid spoon-feeding students.

Challenging but worthwell. More examples in the lectures would be nice, but I guess the videos are already very long. Professor Tannen is awsome and very approachable. Office hours are super helpful if you are struggling. This class builds a strong foundation for discrete math, and logical thinking in general.

This was a great class. Most of the topics covered were new to me, but the lecture videos were thorough enough to cover all the pertinent information, but also concise enough to be digestible and easy to follow. Some questions on the homework assignments felt particularly tricky or overly difficult, but not impossible. There were times where I would spend hours working on a single HW question which was frustrating, but helped me understand the topics thoroughly. The exams were easier than the homework assignments.

This is a hard course. There is a lot of material and the homework is long and difficult. The course really requires you to think in order to solve the exercises. That being said, the exams tended to be easier than the homework. I thought professor Tannen did a great job If you do not have a math background (like me), the beginning of the course can be overwhelming with all the mathematical notation and concepts. However, it did get much better as the course went on. That being said, the grading can be annoying because some graders do not give you points even if the answer is correct, so you will probably have to ask for regrades a couple of times. Overall, it boosted my mathematical confidence after having terrible teachers in high school and made me feel like I can take on harder topics. Props to Tannen for that!

Learned tons in this class and having moved on to some other MCIT courses it is clear that the 592 curriculum was meticulously designed to provides us with the foundation needed to be successful in the future courses. Highly recommend attending professor office hours and TA recitations. They both greatly enhance the learning.

Having prior experience in discrete math and extensive statistics, I find this course to be unnecessarily complicated. I am already familiar with most of the material, but I still have to invest almost 10 hours a week just to maintain an A average. Concepts that are covered at the undergraduate level and even perhaps some high school curriculums are made convoluted with extensive use of specific mathematical jargon which, while technically right, isn't conducive to getting the foundational concepts across. Please note the use of the word *specific*. If you have prior background in the foundational topics covered in this class, be prepared to set that prior understanding aside as you have to conform to the strict terminology used in this course. The rubric will cause points to be deducted for using different, but mathematically equivalent, notation and terminology. Likewise, the TA-ing could be better. Some of the TAs seem to only grasp the material at an intermediate level, enough to accomplish the job, but insufficient to thoughtfully critique and accurately critique homeworks and give alternate explanations to difficult concepts. Most importantly, the head-TA carries an attitude when interacting with students that make one unlikely to seek help again, be it for logistical or scholastic reasons. On the flip side, the TAs and Professor Tannen are the class' saving grace. TA's like Alex N. have some of the most patience I've seen in student staff. Professor Tannen also displays an eager willingness to help students regardless of how many iterations he has to go through to explain 1 topic. The class may not be enjoyable, but Professor Tannen and some TAs certainly make it palatable for a core requirement.

Challenging material, but well taught. Professor Tannen was helpful and active on Piazza. Homework was difficult and tests were reasonable. Lots of extra credit opportunities and typically awards a generous curve.

First two weeks of this course were so hard for me. I hadn't done much math since college and that was calculus which is not needed in this class; so my most recent exposure to this kind of stuff was really high school. Once I got the "math brain" restarted, and I understood what was being asked in the proofs, this class got a lot more smooth.

592 will help you to become stronger in problem-solving and will make you a better programmer. You will dig relatively deep into the Probability and Graph Theories and this material is quite enjoyable. What's not enjoyable is the myth that the average grade is in between "A and A- and if you work hard you would be fine". It ended up absolutely untrue for my cohort, where the estimated average ended up between "B and B+". The overall grading policy is so so. Sometimes you get a good grader that appreciates and reads through your solution and sometimes it's gonna be "the solution is wrong" type of feedback. The most upsetting part is that the professor has a huge ego and is not willing to take any feedback from students (even the simple logistics requests could get him on edge). To summarize, I appreciate all the knowledge I have acquired working hard, but these authoritative teaching and grading methodologies are quite questionable.

I have a math background, so I thought that this course was challenging, but not too difficult since I had seen most of the material before. I really enjoyed it, and it made me better at writing proofs, and I see the material everywhere in the other courses. I ended up taking about 6 hours per week on the course, but out of necessity not because it was easy. I would recommend spending more time than I was able so that your homework scores would be higher than mine were which is a lot easier if you chip away at the problems over multiple days.

Hard class, but I learned a ton. I thought it was structured very well. It's pretty cool to go from 0 math background to inductive proofs in 4 months. I loved graph theory, and thought it was a different, but interesting way to think. Professor Tannen is awesome. I didn't attend anything live, but I thought his office hours were very helpful.

At the time I took this course it had been 10 years since my last interaction with rigorous math. The early part of the semester was a struggle and it felt as though proper support material was lacking. The leap between understanding lecture material and thoroughly understanding the weekly homework assignments was stressful in the courses mid-early weeks (emphasis on weeks 05 and 06). In the second half of the course the transition to Probability and then to Graph Theory, was welcomed. These topics, though at times rigorous and mentally stimulating, seemed more intuitive. The exams were fair with the proper preparation. You will need to at times search for outside materials to aid in your understanding. I believe the Professor and course staff had a genuine care for our success, and I commend their attentiveness to constant communication. Overall, I feel I learned a great deal from this course.

Probably the worst course ever in my life. The course contents are good, but the way they are organized and explained is really poor. For example, in the probability section, he never even mentioned the concept of "identically and independently distributed" (iid), which is so standard and essential that every sophomore in the Stats department knows it. On Piazza, I saw some students are still confused about the linearity of expectation. This won't happen if the concept of iid is clearly taught. Also, some of the notations used in the class is non-standard and confusing, especially those in the topic of functions (mapping, bijection, etc). A very concrete example is that in an assignment, many students on Piazza are so confused with the set of integers and the integer interval. I don't believe any analytical math textbook would use those types of notations or describe a question in that way. The grading is mysterious and frustrating. I totally understand that grading proofs is never easy, but it is not an excuse for the nonsensical grading. Asking for regrading can be risky to you. I have asked for regrading once. The TA admitted that my argument is correct, but only half of the points are returned. After that regrading, my assignments were nitpicked here and there. I even got several points off just because I didn't align the question and page numbers! What a hostility! Since then I never asked for regrading again, otherwise I could fail the course in the end. The course itself still has something good. The design of the assignments is really trying to help you understand those core concepts, but again, sometimes the descriptions of the questions are very confusing. In summary, I did learn something from the course, but the overall experience is very unpleasant and humiliating.

I think the course is of the right level of difficulty. The last part (graph theory) was not taught as well as the others, but it's still acceptable. The exams for my semester were a bit easier than homework. To me, in terms difficulty, 1st > 2nd = 3rd, though the 2nd one was graded more harshly. One piece of advice is try not to leave out any potentially important details in your proofs and answers for the exams. Otherwise you may be unpleasantly surprised by the sometimes strict/unreasonable grading rubrics. Overall, it's a solid course well put together.

If you have a degree in math or some relevant major like natural science or math finance, you will find the course content is pretty easy. If you never learned anything about Graph, the third part may be challenging. But the exams are much easier than the assignment and the practice exam. Generally, it is easy to leverage the course to get a great GPA in your first semester.