This was my 2nd course in the OMSCS program (first was CN). Coming from a non-CS background, I was excited to take this course as I thought it would provide some very functional learning outcomes.

I certainly did learn some important things from this course, but probably not as much as I expected. This course really honed my Git skills, as well as strengthened my Java coding, but I didn’t feel like I took a wealth of new knowledge away from this course.

Pros - Professor Orso is fantastic, his lectures are enjoyable to watch, and he’s quite active on the message board and with office hours. TAs all pretty good too, response times were very quick.

I really enjoyed the individual assignments, as I thought they were well documented and easy to understand what the objectives were. Learned quite a bit from these.

My group was very active for the group project (albeit a little last minute on some things). We got a solid A on the project.

Cons - While the lectures were enjoyable to watch, I don’t feel like I retained the knowledge that well since we aren’t tested directly on the material. Sure, some of the lectures were pretty key as a demo for some of the assignments, but I felt like you could really skip most of them and just get the assignments and projects done to coast on by.

The group and individual projects were just kind of blah. There really wasn’t an excitement to working on the applications needed to be developed.

Overall, I am still glad I took the course, I just don’t think it quite lived up to my expectations.

Overall a great class. This is a must if you do not have a standard CS background. You will learn very useful skills that are applicable in the future. In my case, I would say that is NOT an easy A, but if you put in the work you will get a good grade, which is very fair. Highly recommended at the beginning of the program or if you do not have a CS background.

This was the 2nd course I took in this program. First I just want to say that I do not have a CS background but am proficient in Python and Javascript and taught myself some basic Java before starting the class. If you have a similar background, you will definitely be using google a lot and these project may take you slightly longer to complete compared to others. This was the case for me, but still managed to get an A in this course pretty easily. I would recommend this to anyone starting this program or looking for an easy course to end the program with.

Overall I learned a lot in this course and found the subject very interesting. I was really happy to learn how to use Git in collaboration with teammates which is a useful skill. I also liked that there are no tests or graded quizzes and MOST the lectures were pretty helpful. Orso does a good job of presenting lectures so they are actually bearable to watch.

Most students complain about the group project and unfair grading. My experience was pretty positive and I felt that any points lost were fair and couldn’t be argued. Based on previous feedback I was pretty nervous about Assignment 6 but surprisingly found it to be one of the easier projects. This assignment didn’t involve any coding, but did require you to watch the lectures and read the questions carefully and apply some logic. Despite my experience many people seemed to lose a lot of points on this.

The individual project was a bit more challenging and the first Deliverable was the most tedious part. After that it was not so bad. Most of the Individual Project is submitted in the autograder so it was nice to see the feedback and scores for the assignments.

Complaints: I think the most common complaint is about the weighting. Assignment 6 was 15% of the grade and this is where many people lost points. I think it would be a good idea to spread the percentage out over all assignments more so one assignment doesn’t have such a huge impact on the score.

Final thoughts: If you are looking for an easy A or have no CS background and want to improve your Git and Java skills, take this class! If you are already a software engineer or have a solid CS background and you want to actually learn/challenge yourself, this may be a waste of your time.

The most thing I hate about this course is Orso’s headphones. Every time he attended the office hour, his voice sounded muffled, and far away. His headphone quality is really low making the every office hour a total disaster.

About the course, the content is too high level, and lack of detailed practical materials. The group project didn’t allow us to choose group members. Instead, they chose crapy members for us. The individual project contains full of boring repetitive assignment like creating 50-90 test cases.

If you are a software professional, you will find this course too easy, too boring and nothing to learn. If you are a newbie, you will find this course too vague, too out of scope, and nothing to learn

The lectures in the class are good and engaging. Prof Orso is creative with different content delivery methods, like interviewing experts in the field and being animated. Some of the interviews had audio quality issues and were not filmed with professional quality.

I disliked the course overall because it’s a lot of busy work for those who have experience. I wanted to learn more about design patterns and UML, and apply them in code, but those subjects were briefly covered. The group project was unpleasant because they pair strong students with weaker students, practically inviting free riding. For the final individual project, the project is as dull as possible, and you have to implement 50-90 unit tests! It is an easier course, but there’s little educational take away.

Taking this course is a waste of time unless you have 0 professional coding experience and haven’t covered any of these topics in previous courses.

Otherwise the only value of taking this course is to get any easy A for like 5 hours of work a week at the cost of not learning anything and doing boring / repetitive work (final project is actually a decent amount of work because there’s so much tedious repetition in it - e.g.: write 50+ unit tests testing slightly different permutations of the same thing)

As someone who’s been programming for years, including some time doing Android development, this was a pretty easy class, but I imagine not so much for folks without a lot of experience in programming. Still, I enjoyed it immensely as it was a good refresher of best practices as well as some theory that I’d never been exposed to for things I’d been doing for a while.

Easiest course I’ve attended so far and yet the first course in which I was graded with a B. To set a benchmark, I’ve attended much more challenging courses like AI, KBAI, HCI, IHI and have had straight A’s.

The manually graded assignments which include White box testing (A6) and Group project is a complete joke when it comes to grading and mind it these assignments come towards the latter part of your semester and are very very badly graded by the TAs, while the weightage given to these assignments are also very high.

Points are taken away even if you have done all the work and when you challenge the grade, the TAs do their best to find arbitrary faults to justify.

As an example, my group project was graded 50/100 saying outright that the app doesn’t work and that the documentations were missing. Then me and my team showed proof of the working app and that the documentations were present. After multiple regrades and back and forth with the TAs it was regraded to 76/100 and still the grade did not justify the efforts we put in.

I ended up with a final score of 89 and received my first B for the easiest course that I’ve taken in OMSCS. This course does not grade you for your work on the manually graded projects and relies on the mood of your TA evaluating. Worse experience!!!!

As someone with NO software development experience, I really liked this class. I learned something new every single week and got practice using GitHub (which I had never really gotten the chance to use before). The assignments matched up really well with the lectures. Even though people complain about not having all of the assignments released all at once, I think that they are released that way so that the lectures and assignments are in sync, which is actually kind of nice for spacing out your own learning in manageable chunks.

If you have a good group, the group project can go really smoothly, and it’s a lot of fun getting to make an android app if you’ve never done it before.

Though it did not affect me, I do know that grading was fairly harsh and unforgiving for some of the assignments (i.e. Assignment 6).

I think opinions of this course are largely dependent on 1) how much people already knew going in and 2) grading, so consider your own experience carefully when going into this course. If you’re familiar with Java and OOP, I would guess that you’ll be fine. If you’ve done software development in the past, you will more than likely be bored in this class.

If you had experience working in the IT industry this course wouldn’t be that big of a deal for you. I have a background in software testing and this course was pretty easy for me. Just make sure to read the assignment carefully before starting. The only issue you might have is team assignment which basically depends on the entire team’s performance. Worst case scenario you would have to do it alone. Luckily this assignment is not that hard overall and if you developed an android app for leisure or have experience in Java programming you’ll manage it. My team was not that bad at all, only one person didn’t code. Overall I enjoyed taking this class.

SDP is a fairly easy course - I am new to Java and I was doing well.. until

The Assignments 6 and Individual Project.

So I was doing pretty well in my first assignments. I did learn a lot from the group project - proper git usage, proper communication with groupmates, models and Android in general. However, I really dislike the fact that the grading is so artificial. I think they are intentionally failing students maybe because the course is fairly easy so there should be students that SHOULD fail.. not sure.. I don’t like to accuse, but this is just a feeling.

Also, gradescope is acting crazy. I have already complained about the unfairness that surrounds this tool but who cares .. TAs are not the best at all about helping.

In all fairness, I have learned a bunch in this course, as a newbie.. but I strongly dislike the grading, it is not fair.

SDP has the potential to be a great and very useful class but there are currently a lot of issues with it. First off, prepare for a lot of unnecessary tedium, vague instructions, and shady/lack of transparent grading which is really an attempt at artificially increasing the difficulty of this course.

The 6th assignment in this class for example was extremely vague and was graded pretty harshly. Compared to the group project which had multiple deliverables and spanned over a month, assignment 6 had a one week deadline yet was worth %15 (3% less than the group project).

For Assignment 5 which was a much much simpler assignment than assignment 6 and was only worth %2 of the final grade, it literally took TAs an entire month to grade this which is completely unacceptable.

No feedback was provided each week for any of our one week deliverables for the Group Project. And it was almost a month after submitting the final project that we actually received a grade. This would have been fine if we received feedback for each deliverable, but it never happened. So between the first week of Oct and late November, we were completely left in the dark on how our project did. Only to finally get a project grade with vague, trivial and nonsensical point deductions.

The assignments which involve using Git, working with Junit tests and using Android Studio are very helpful and have good value, especially for newer programmers. But again I’m not fan of this course’s grading practices, TA attitude problems (especially on Ed) as well as how the Group Project and subsequent assignments were handled.

If you have no background in coding, this class is not easy. The assignments are not difficult, but the individual project is really challenging for me. Really don’t know how to do the last 2 deliveries. I think everyone says it is easy because for group project, you will be assigned teammates who are good at java, most likely a software engineer. But the course content is not easy.

Good class if you are taking 2 courses (this and a hard one). I was able to balance well and learned a decent amount.

I see non csers struggle in this course for some reason. Makes me question if they can survive the other easy courses especially if this is their first or second semester class.. had a non cser in my group definitely gave him the minimal for contribution

Background about me: Mechanical Engineering. CN(Fall 2020), GIOS, DL, GITA.

The definition of easy A course:

• You will contribute little efforts.
• You will learn barely nothing.
• You will receive a beautiful A grade.

I thought this course was a boring easy A course, since it was reviewed almost the lowest work load in Computing System track.

But it turns out I’m wrong about the above impression:

• I have contributed some efforts (SQLite API, Test Driven Development).
• I have learnt something from the group project and individual project, which I will detail in the next paragraph.
• I don’t care if I can get A or B at the end.

Group Project:

• Experienced team members taught me the followings: Wisely usage of github, data persistence implementation, Data Access Object and Business Service for Object Oriented Programming.
• I have never expect that I can get any positive learning experience from a group project of online degree program. But this course changed my mind. I’m lucky enough to be assigned into a positive group.

Individual Project:

• Test driven development.
• Basic I/O operations with java
• Object Oriented Programing.

Overall, I received more than I have spent on this course. By contrast, I have almost spent the same time on CS6250 CN. But I literally received nothing from CS6250 CN. Although I received an A from CS 6250 CN, the contrast of the bad learning experience of 6250 to good learning experience of 6300 are obvious due to the followings:

• SDP designed solid projects for students to finish, in which some important concepts(such as TDD, OOD/OOP) were delivered through individual/group projects.
• Compared with SDP, CN has much more abstract/broad concepts needed to be delivered. For 6250 CN, I even don’t know which concepts should I learn, how well I’ve learnt from Exams/quizzes/projects.
• SDP is different from 6250 CN. You can expect to learn some important concepts/programming methodology from SDP with reasonable efforts.

TL; DR, reasonable positive learning experience with reasonable efforts.

Very easy course. No test or quizzes so you can choose to dive into the material if you desire or just focus on the assignments and projects. My group was incredible and everyone knocked their portion out of the park! There is definitely a little more work in the end of the semester but its not a ton more. I don’t think there was a week I spent more than 6-8 hours ever in this course. If you are going for perfect scores on the latter assignments you might spend longer. If you are just looking to get an A, you shouldn’t need a ton of time.

As for the material its good for an intro definitely. You should after this course have enough knowledge to more heavily research any of the areas covered. Would recommend pairing this course with another or taking this course a semester you know you’ll be busy or need a little time to de-stress.

Pros:

• Interesting content especially for someone with limited background in software engineering. For me it was useful to review git/github, software testing, and java basics, but for someone with a lot of experience in those areas it might be too simple.
• Enjoyed the assignments with the exception of the group project.
• No exams and almost no reading. Only a small amount of writing required to produce documents for the group project.
• Many assignments have an auto-grader so you can get your grade right away and can make changes to your work as necessary.
• Probably a light enough work load that this class could be paired with another class

Cons:

• I got a less than stellar group for the group project and it was very frustrating to feel like I was working on my own for long periods of time. On the up-side, at least the group project counts for a small enough part of your grade that as long as you don’t bomb it completely, you can probably pull off an A in the class based on your individual assignments. If you’re worried about getting a bad group and want to prepare for doing the group project on your own, my advice is to learn as much about Android studio and building Android apps as you can. Learn how to make a responsive layout and how to persist data in a database with the Room library and you can probably crank out the whole project in less than 20 hours a week.
• Professor and TAs repeatedly discouraged asking questions. I understand that it’s frustrating when students ask questions they could answer by reading the assignment or by googling, but one of the main reasons I’m part of this program is to participate in discussions with students, TAs, and professors. Telling students repeatedly that they should not be asking questions isn’t a great way to encourage collaborative learning.
• Grades take forever to come back for assignments that aren’t auto-graded so it’s hard to tell how you’re doing in the class.

This semester we had:

• A1: Team Matching Survey (2%)
• A2: Git Usage (5%)
• A3: Basic Java Coding and Junit (10%)
• A4: Simple Android App (Java Only) (10%)
• A5: Software Design (2%)
• Group Project (Android App Java or Kotlin) (18%)
• Collaboration (Group Project) (10%)
• A6: White Box Testing (15%)
• Individual Project 3 Deliverables (Basically 3 Assignments) (25%)
• Participation: Watch lectures and read every Piazza post (3%)

Liked:

• First 5 weeks took less than 10 hours and easy
• Group project in Kotlin
• Class is not difficult tech wise

Disliked:

• While not difficult it became time consuming starting after A5.
• I hated A6 and the individual project. Super annoying assignments
• Can’t work ahead. Assignments came out Saturday and closed the next Monday
• If it’s not autograded then you will never know the grade until the very end after the individual project. So, the group project, A6, A5, some of A4, and the first part of the individual project.

I have industry experience 7 years. Basically, I liked this class for how easy it was at the beginning. I probably spent less than 10 hours on this class until A5. Once the group project started the amount of time increased. My group went with Kotlin for the android app. I rather liked the group project. Although everything after the group project I really hated. A6 really leaves a bad taste in my mouth. I understand the concept needs to be taught in this class, but 15% for this bs man come on. Why make A6 the make it or break it assignment? It is way to easy to bomb just one of the 5 questions on this assignment to tank your grade. The individual project is especially annoying. D1 TSL generator really sucks. Someone in EdTech should make this a project to replace this with a GUI. So, if you are going to take EdTech in the future please do this and save future students! So, D2 is making unit tests against the instructor’s program. I would plan to not get 100 percent on this assignment unless you have hours and hours of time. Getting an 85 – 95 on D2 is easily in the realm of possibility. D3 is actually making the program. Same deal as D2 though plan to not get 100 on this. I would say returns start diminishing at the 90 percent range.

Ignore the “you won’t learn anything here” comments from people who already have a full cup… given that a high percentage of industry professionals simply can’t write good tests, and an even higher percentage wouldn’t know how to elicit requirements from a customer if their lives depended on it, I find it implausible that so many review here with “yeah, we already know this, easy A.” Right. Watch out for those people; don’t hire them.

If you are a competent, capable professional, you will still get something out of this class, and yes, you will likely get an A (grades are not out yet, but that is my expectation as well).

You will have to contend with the usual band of people who begin an assignment 8 hours before it’s due and ask questions indicating that they haven’t even read the instructions yet, and with the “what does main() do, newbie programmer here” crowd. How these people can look themselves in the mirror if they eek out a degree and claim to be “masters” in computer science, or why GT lets them in to begin with, is beyond me. But I digress.

Dr. Orso and TAs are helpful. Instructions are clear, if only people would read them. The quality of the lectures is pretty good as well. There is a group project, but if you are a quality software engineer, or seeking to become one, then any shortcomings in your group can be reconciled.

The individual project was extremely helpful in solidifying how to achieve good test coverage, without an explosion of test cases which become impossible to maintain.

In short: it’s one of the few options for actually exploring software engineering in OMSCS, and it’s a worthwhile class to take, even if you’ve been in the industry for some time. If you can code (surely you can–you’re in grad school, aren’t you?), are studious, know how to read and follow directions, and can work effectively with others, then you will have no problems in this class.

I disliked this class, mostly because of the grading scale and the nature of the assignments. There’s a lot of tedium associated with some of the assignments, and I didn’t feel that they were necessary in order to enforce the concepts. The course feels a bit outdated, but I would recommend the course if you don’t have experience yet working as a developer. If you do have experience as a developer, you won’t learn much. I mostly just took it as an easy A.

For a more in-depth overview of the course, please watch my video overview of the course on Youtube, where I break down each assignment/deliverable for the course.

This class is fairly easy, especially if you already know some java and how to use tools like git. I got an A very easily.

Something to watch is that it’s backloaded: I spent maybe a half hour per week on this class until the last few assignments where I spent a large amount of time.

Be careful of A6/The individual project. Together they make up almost 40% of your grade and all happen in the last few weeks, and they’re not straightforward. A6 in particular: learn what a nested if statement is (note: an if/elseif is considered a nested if statement). Many students bombed this assignment because of that misunderstanding and lost a letter grade.

The individual project has 4 parts. The latter 3 parts are autograded in gradescope. The first part uses an outdated test case creator. This first part is where students lost the bulk of their points. I spent quite some time on it and got only a ~40% (not enough to hurt my grade). The professors make it seem like if you give it a good effort and learn to use the tool you’ll get full marks, but they’re looking for you to check specific test cases/scenarios, so be aware.

Regarding the content: I honestly didn’t really care about it because I just needed a second class and want to graduate. I’m also a software engineer so I didn’t really learn anything all that valuable other than the idea of path/branch/statement coverage which was an interesting thought experiment.

Overall, very easy but don’t sleep on the last few assignments and make sure you read the directions carefully.

I came in without any java experience and I was able to survive. This course is extremely well run. Prof Orso is very involved in the course (piazza and office hours). Most of the assignments are autograded, so that is a plus. A couple of assignments are manually graded and the return time is very long. They need to hire more TAs. Group project depends on your team members.

Overall: Very nice course, hands on and practical.

As can be seen from other comments, if you don’t come from a programming background this might not be for you. Competent knowledge of Java / debugging code / Googling questions will be needed to not really overexert yourself in this class. My review is from a perspective of a software engineer with a few years of programming experience.

Pros:

• Accomplishes its goals of going over some software development strategies. A lot of it is common sense but the application of those concepts was well-honed in assignments, however tedious they might seem.
• Professors and TAs are pretty active / willing to answer questions on Piazza
• Assignments are auto-graded/pretty straightforward
• No exams
• Material is pretty easy to understand

Cons:

• Assignments are tedious at times (cost of trying to enforce concept understanding)
• Material is pretty derivative if you are doing software engineering fulltime. To be perfectly honest, I barely had to expend much effort on this class and only spent time on the projects/assignments maybe 1-2 days before they were due.
• Last few assignments are pretty big in terms of weighting/work and takes a bit to get graded.
• Does not seem suited for people that are looking for hand-holding when it comes to programming problems. Be able to google issues for yourself and definitely be familiar with Java!

If you have a few years of software dev under your belt and looking to double up classes, this will be your best bet. I doubled up with another class this semester and had very few issues. Definitely the easiest class I’ve taken so far.

The course is great for developers that want a good refresher and a greater focus on software testing. The course starts out low for work load and then picks up towards the end of the semester. The content isn’t difficult but I would recommend having a background in software development. Also, this class is a deliverable due every week kind of class but no exams.

A1-A4 are light weight assignments and you should easily get a 100 on these due to the auto grader. I wouldn’t slack on these because the end of the course is the most difficult and is most of your grade. A5 is pretty straight forward if you put effort into it.

Group Project: I was lucky with my team and we were evenly placed based on experience. The group project and A4 are android apps. I enjoyed this because I have never built an android app before. My team put the work in and received 100%.

A6: A6 was challenging, you will learn white box testing in depth by the end of it. No auto-grader for this one, and we still don’t have the grades. This is weighted heavily.

Individual Project: This was interesting…. and tedious. Learned a lot about test driven development but it was just a pain submitting to the auto grader a million times to see if you got the coverage you needed. Besides deliverable 1, you will know your scores. 4 deliverables total.

Pros:

• Very active professor and TA
• Easy for experienced developers
• Most assignments are auto-graded, so you know your score and can re-submit until you get the score you want.
• No exams
• The slack is active

Cons:

• The last three assignments are more than half your grade.
• Grading takes awhile to return unless its the autograder.

It’s a good class and it’s very easy/low amount of hours until: -Group project (at least it’s straightforward) -Individual Project

The individual project killed this course for me. Documentation is vague. The 4 assignments related to it are extremely tedious and irritating. Implementing the utility itself is a slog because it’s not interesting (it’s the unix cut utility). Also, be prepared to spend at least 10 hours a week here, whereas most of the semester its like 5 hours or less.

Also, the grading towards the end has been horrible. Done with the course as of today and 40% of the grade is still up in there air and unknown. So far it’s been over a month since we had Assignment 6 and still waiting on grades for it. Who knows how long we’ll have to wait for grades for the individual project (last assignment). The individual project and the slow grading for A6 has left a bad taste in my mouth.

Overall, this class was a good one.

The pros:

• Professor active on Piazza, unlike many other classes in the program.
• Professor acknowledges students who are always helping others in Piazza. It’s probably the class where I saw the most students with a instructor-endorsed answerer badge in Piazza.
• Videos are watchable: to the point and not boring, though the topics are a little outdated if compared to modern industry standards.
• Many hands-on assignments that required coding, though the level of the challenge isn’t that high for those with experience in the industry. This is understandable because it’s an academic class and it does not expect students to have prior experience in professional software development. Therefore, if you have some experience, the class might not challenge you much.
• Most of assignments are autograded, so it removes part of the anxiety in waiting for manual grading.
• Group project is interesting.

The cons:

• Content is not very relevant to modern industry development. There are relevant parts like agile methodology, design patterns and refactoring though.
• Group project, like in any class in the program, can be hit or miss. I had a bad group and ended up doing the bulk of the work (5000+ Loc). However, I didn’t know any Android development prior to the class and it was a good opportunity to get some experience with it. A con is that most of the Android resources are in Kotlin nowadays, but the project required Java, unless your entire team agree on Kotlin.
• Not a fault of the class, but many students don’t appear to be comfortable with Java or basic programming and flood Piazza with really trivial questions, most easily answerable by a 30-second Google search or a bit more tinkering. With that, Piazza often becomes bloated, hard to navigate and find the golden nuggets.
• The individual project is bad. This is particularly bad because it’s how the course ends, therefore it has the bigger impact in the students impression of the course quality. What makes the individual project bad is that most of the deliverables are not challenging in a good way. For example, in week 2 we had to create test cases for a command line application that we didn’t have access to. To earn points, though, those tests had to cover the same things as the instructor’s hidden tests. I came up with a lot of different tests that the instructors hadn’t thought about, but wasn’t rewarded by that. Moreover, getting, let’s say, 85% of the total points was pretty easy, but to get 100% it required 10x or more the time invested, but this time spent wouldn’t necessarily translate into learning since it’s a brute-force find-the-hidden-tests endeavor.
• There was one TA who probably oversees the individual project, but I don’t remember seeing the other TAs on Piazza the entire semester. Maybe in a thread or two. They probably help the most with grading, but it would be nice to have a more balanced presence on Piazza since most of the instructor answers are always by Prof. Orso.
• Manual grading of some assignments can take a long time. It didn’t bother me, but some students were anxious about it.

Overall, it’s a good class, just set your expectations appropriately and be flexible.

This class was very straight forward. Perfect for taking after a burnout semester. Very well organized, both Professor and TA’s are very responsive. I had an “OK” group for the group project, I ended up doing a majority of the work, but the group project wasn’t worth as much as the individual project, which was satisfying. The material itself is very high level, but gives you a good overview of certain development processes that exist in the industry. I had no Java experience coming into this class and had absolutely no problem learning it on the fly. This should be an easy A for anyone who takes this class.

This is a very well-organized course where the assignments are highly correlated with the lectures. The professor is one of the best (in my experience the best after 5 courses) in terms of involvement. He is always in office hours, resolves one by one all the questions and he is very active on Piazza, even providing answers to follow-up questions.

This class is the perfect example of a class that can be easy but you will enjoy and actually learn by doing the assignments. For example, I worked before in testing and verification, but in this class, I realized that some of the concepts in this area were not so clear as I thought. In one of the assignments related to white-box testing the assignment looked easy, the coding was minimal, but I had to think a lot to make sure I was applying the concepts correctly.

Also, contrary to what I initially thought, the group project was highly satisfying, maybe I was lucky, but the instructions were very clear and allowed the group to organize very well to plan, design, and implement a small project. In the end, all the members felt this was the best group of our career (XD).

Now, I could imagine that if you already took several courses related to testing, SW design, arch, and continuous integration tools, you might feel that the course will be basic for you. My experience comes from EE background, but somebody from the group was also a CS minor and she also enjoyed the course.

Having said that, I would say this is the perfect class to take after burning out a course (like ML) or to pair with another low demanding (something in the range of 10-12hrs). Actually, one of my group partners took it with GA and he still was very active in the group, but I guess it depends on the workload that you can take and experience.

finally, I highly recommend this class in terms of usefulness, low-moderate workload, and organization.

I wish every course at OMSCS could be like this one. It’s super fun, if I could take it ten times to get the degree I would. If I had to do the group project alone, I would, and I hate working hard. The lectures apply to the material unlike other classes. The material is taught like they got some sense instead of encrypted with meaningless unrelated assignments like in every other class. The instructor responds to every single student Piazza post. Again, this is the only class where that happens. There are no exams. Exams are the absolute worst thing in the world. Me and one other person put a lot of effort into the group project and seeing our code mature into a beautiful butterfly was a wonderful experience. The other two group members performed like I would expect from average students: they do one or two things and let you do the rest. And I absolutely loved it this time. For once it’s not busy work, it’s an actual fun project with many possible relevant solutions. Android studio is fun to learn. This class is flawless.

This should certainly be an easy class for you if you work with Agile processes. The lectures are pretty straightforward, there are no tests, and the assignments for the most part can be completed by noon on the morning they come out.

If you already work with software and your goal is to only take classes where everything will be new material, then yes this class is not for you. However, if you accept that you may already know a lot of the material, it can be a nice refresher and you can probably still learn some in terms of fine-grained design and testing. And honestly most of us have probably had a stressful enough time with grad school and work that this is a nice break.

Major Pros:

• The professor is amazing. He is very active with the class and extremely reasonable. He responded to and made changes based on classmates requests.
• Easy to be paired with another class, or to be taken a semester when you’re short on time or need a break.
• The assignments are not released until a week before they are due. I know, this can seem annoying for those that like to work ahead and I was concerned about it myself. It actually turned out to be pretty nice. You just did the work assigned (usually in very little time) as it came out and then were free until the next week.
• Most assignments are auto-graded with unlimited submissions.

Undetermined Sentiment:

• There is a group project and groups are assigned by the professor. The project went pretty well for my group and the application was pretty simple, this will obviously vary based on your luck. I think its always cool to learn different styles from other people, which is a positive.
• The assignments are very simple at the beginning and are a bit more heavy after the group project. Just don’t be shocked by the sudden increase in workload, its still not bad though, just more in comparison to the start.

Overall: Pretty chill class with a great professor. Try to learn something, even if you know everything.

This course is relatively easy one. You could easily get a good grade if you put some effort into it. And you could learn a lot if you do not have too much knowledge about software development. The instructor is awesome! He is the most responsible instructor among the 7 courses I took. TAs are good as well.

The reviews from other students accurately capture the good and the bad parts of this course. I won’t go too much into the details since they are provided in other reviews, and in Fall 2020, the structure of the class has not changed from previous reviews.

The Good

Course organization: Each week had a deliverable. Although I liked this, some students did not due to personal time constraints, so keep that in mind when deciding to take the course. For me, this kept the course pace moderate, and I never felt overwhelmed. The assignments have been tailored to be completed in the time frame provided. The first few assignments are a type of sanity check to make sure you are ready for the course, which I think is a great idea. If you can complete Assignments 3 and 4 without issue, you’ll be fine. The write-ups for the assignments were well done, and any clarification was answered swiftly by Dr. Orso.

Professor Participation: I have never seen a professor that is as involved in their course than Dr. Orso. He held weekly office hours as well, and I am relatively certain he answered every post on Piazza personally.

The Bad

Course content: This is highly subjective and really depends on how much experience you have and what your goals are coming into the class. For myself, the course was somewhat unexciting. I enjoyed the Android programming assignments, but not much else. For someone that has little experience in development, this class may offer more satisfaction, but for any experienced developers, I feel you will have the same opinion as myself.

The group project is difficult for me to categorize as good or bad. I don’t mind group projects so much, but depending on your group, it could be a chore. In the worst case scenario, I think you could complete it by yourself.

The individual project is a bit of a chore. The second part of the project was the worst for me, which involved writing test cases to test certain scenarios for the application you are charged with writing. This was mostly a guess and check assignment, and to me did not facilitate learning anything.

I had somewhat corrupt reasons for taking this course. My main goal was to find a class that I could pair with a more difficult course, and it definitely succeeded in that regard. I don’t feel it is fair to rate the class negatively for this reason. This course has the goal of teaching Software Development methods, and in that regard it succeeds. The class is fine, but I wasn’t excited to complete assignments or anything, and really did not learn much.

The class was made up of assignments, a group project, and an individual project (no tests). I had no java experience, but a lot of programming experience including test driven development (TDD) and had no problem getting through the assignments.

The group project was an Android app, which is possible to do on your own if you have bad teammates. I was lucky and had an excellent team)

The individual project was fairly straightforward and broken down into phases to practice TDD.

Takeaways: I learned a little java, which was my overall goal. I learned I do not care for android development, but I feel it was a good tool for learning the content of the class. And if you don’t know TDD this should be on your list of courses. If you already know it and don’t need to learn Java, I would probably skip the class

This is an easy course (considering you have experience with Java) where most of the assignments can be done by giving a few hours. There are a few new concepts to learn in this class, such as UML design, developing a project using TDD, making an android application, etc.

The group project was about creating an android application. It is quite extensive and takes up a lot of time. The amount of documentation required is also quite exhaustive. I had a wonderful team for a group project where we all divided our responsibilities and finished all the deliverables on time. I had to spend more than 20hrs/week during this group project phase. We had a great experience doing the group project, but I am not sure if this will be the case for all the groups.

Apart from this group project, other assignments won’t take up much time. Regarding the lecture content, most of the assignments and projects can be done without going through the lecture.

Coming from a non-CS undergrad background I was pretty excited for this course. Unfortunately it didn’t live up to my expectations.

In general I found the content weak. I ended up not watching the second half of the lectures simply because I wasn’t getting any value from them. The one concrete take away from this course is how to use Git effectively, which is in itself quite valuable, but that was covered during the first two weeks.

All but the last project can easily be done in under 5 hours. As others have mentioned, the group project can be a nightmare. In general a group project is nobody’s top priority and I won’t be taking another course with a group project as a result of my experience with this one.

I did enjoy working in Java the whole semester because I hadn’t had much experience before this course. Beyond that and Git, this course felt like a waste of time.

I know most people enjoy this class, but I did not. There is some good topics in the course, but I don’t think the material is handled well enough for me to say that the content is particularly good. That is to say, if I just had the syllabus and read about the topics I wasn’t already familiar with on my own, I would be no worse off.

(1) I found much of the “Software Dev Process” content was never connected to how actual code is written. So today I’m just as good or bad of a developer as I was before this course. To make use of anything covered in the class will take quite a bit more work. At best, right now I’m at a place where I know there are a bunch of design diagrams that I could make for future projects. Will I…? No, I would still need to learn a lot more about converting schematics into code for it to be worth my time.

(2) I spent a lot of time getting Android Studio to work properly. I strongly suggest testing both IntelliJ and Android Studio right away to the specifications stated by the class.

(3) About 35% of the class will revolve around using Android Studio to develop apps. On the one hand, these weeks had assignments that were more straight-forward compared to the rest. However, I personally have no need for app development so it was a lot of time spent learning things I won’t use.

(4) The professor is very active on Piazza. It’s great for when assignments need to be corrected, which happens often, but is understandable and thus appreciated. But they very actively discourage discussing anything about anything in detail. That is, don’t expect any practical answers by anyone on the forum apart from assignment corrections. This is my biggest distaste for the OMSCS program in general; it’s always a struggle to figure out what is “appropriate” to talk about in each class. So much so that often times I find it easier to just not bother asking at all even if I was genuinely curious to begin with. I understand the impetus to prevent cheating, but this is grad school, as in, the value of grades is dwarfed by the prospect of actually learning something. But in these OMSCS classes, we often hamstring the latter for fear of degrading the sanctity of the former.

If you have use for an easy A or a light survey course on Software Dev Process, take this class. I am glad I did for both those reasons. But don’t expect anything else.

This was my third course in the OMSCS program. I have almost a decade and a half of software development experience. Reviews prior to taking this class led me to think it would be along the same lines as my undergraduate Software Engineering course. This was pretty spot-on. While the class focuses a lot on the overall process, documentation, and design aspects, there were some useful takeaways for me. It is an entirely project-based course, which means no exams. Various assignments made me more familiar and comfortable with Git, Java, and Android development. The professor is very involved in both the office hours and on Piazza. The TAs were pretty good and responsive. If you have any software development experience, I wouldn’t expect too much from taking this course. Some of the individual projects were challenging and confusing, and the team project comes with the standard “have good teammates” statement. If you are new to software development or just need an easy course, this is a great one, especially for a summer course.

Assignments

• Assignment 1 (2%): This is a survey used for forming teams. You are not able to request teammates.
• Assignment 2 (5%): This is a simple assignment on getting familiar with Git. It can be knocked out quickly if you follow the instructions exactly. It is all command-line based. You can use a GUI later on, but you must/should use the command-line for this assignment.
• Assignment 3 (10%): This assignment is a quick introduction to Java coding and JUnit tests.
• Assignment 4 (10%): This assignment walks you through creating an Android application. It is great if you haven’t done Android development before.
• Assignment 5 (20%): This assignment focuses on white-box testing. You definitely need to understand branch, path, and code coverage.
• Group Project (15%): There are four deliverables for the team project. The first is mostly design documentation (UML Class Diagram and reasoning). The second is updated design documents (project plan, use cases, and test plan). The third is revised documents, a user manual, and a prototype of the Android application. The last is the completed Android application and updated documentation.
• Collaboration (10%): This is labeled as collaboration, but it is purely an evaluation of your teammates work on the group project.
• Individual Project (25%): There are three deliverables. The project focuses a lot on black box testing by creating test cases and developing an application conforming to those tests.
• Participation (3%): These are easy points. This is watching all the lectures and doing all the checkpoint quizzes within the lectures.

Take-Aways

• Miscellaneous Stuff: Do the assignments. Most of them are easy, fun, quick to complete, and straight-forward. The instructor and TAs are helpful and very proactive in Office Hours and Piazza. Start assignments early. They may not take long, but it gives you more time at the end of the week to relax or fix any mistakes.
• Textbook: There is no textbook or reference material for this course.
• Team Project: You can’t pick teammates, so you are at the mercy of the TAs as to who will be on your team. They use the results from A0 to create the teams. I am in EST. One teammate was also in EST, but the other 2 were in PST. This made it a challenge at times to get together to work on the project. While a project manager is not required, have someone in charge who truly understands software development. I feel I had the most experience on our team, but the person who took the lead probably had the least amount. It made the project fun. I felt there were parts of this project not really required, but I understand they were put in to understand the overall development process. Some of the documents required were not completely clear on what they wanted, but they were easy to figure out. The application itself was easy to complete. DO NOT OVER COMPLICATE IT. Our team lead insisted on a crap ton of branches and pull requests, to the extent of it making it a mess when it came time to merge and submit. Keep it simple and knock it out early. Worst case, it is a small enough project for 1 or 2 people to do by themselves.
• Individual Project: This was a pain in the rear. Deliverable 1 gave you a Linux command with command-line options. You had to use the TSL category partition test frames to create 30-60 JUnit tests. It is very easy to get a low grade on this deliverable if you do not fully understand the task. I calculated my grade to be around a 50 on this deliverable. Furthermore, if you get started on the 30-60 test cases and realize you didn’t capture a possibility, there was the likelihood you would have to redo (or at least review) the cases you already created. This happened to me several times. D2 had you possibly revising test cases. You ran the test cases you created against a sample implementation of the Linux command. As extra credit, you could implement the command, but it had to pass your test cases as well as unknown test cases created by the instructor. My grade on D2 was 109.78 out of 100 because I couldn’t figure out how to handle 2 of the instructor’s unknown test cases from the error results. If you did the extra credit on D2, you had a large portion of D3 done as it required the implementation of the Linux command. You also had an option for extra credit by providing more test cases to pass your implementation as well as the instructors. On D3, I received 110 out of 100. Deliverable 1 is definitely the hardest. Even with good scores on D2 and D3, I still received a 89.64 for the overall individual project score.
• Exams: No exams made it more worthwhile and focused toward the process.
• Professor and TAs: Dr. Orso made the class interesting and engaging. Will Johnson, who was also a TA in DB, was great. There were a couple of TAs that never appeared in Piazza or Office Hours. I was afraid I was going to be bored to death in this class, but Dr. Orso’s involvement and understanding in the course made it much more enjoyable. Also, I have never seen a professor more involved in the Office Hours or responsive to emails or Piazza posts. If you had a question, he was more likely to answer it quicker than a TA or student. I feel this class was made much better than I expected purely because of the instructional staff.
• Overall Grade: I feel like I put an acceptable amount of time in this course for it being over the summer. I also feel I played a large part in the team project. I received 100s on A1-A4. A5 was a challenge at 68.33. Only a final grade is given for the team project, which was 97.5. The individual project was a true pain. Deliverable 1 was about a 49, D2 was 109.78, and D3 was 110, giving me a 89.64 on my individual project. In the end, I received an A in the course with a score of 90.7. Some of the weights are a little heavy, but this is probably due to the 5 assignments over the summer compared to 7 during the fall or spring. A lot of students had issues with a low score on A5 and A5 being worth 20% of our grade.

TLDR

In short, if you have had a software development course and/or experience, this class may be a waste of time; however, if you are needing an easy grade or refresher, this class may fit the bill. For me, I feel the summer is the perfect time for this course; however, if you want to take it during the spring or fall, you should be able to easily double it up with another course. The material could be updated a little. The instructor and head TAs are great. Over the last year in the program, I have read the reviews. As a result, I encourage you to read some of the other reviews for the course. Many of them, this course included, aren’t far off from the truth.

This was my second course in the program and was a vast improvement on the class I took last semester. If you are a newer student I highly recommend you take this course first to ease your way into the program.

Pros 1) This class is very well organized and run. 2) The teacher and TA’s are very engaged and helpful. This teacher clearly enjoys what he does and it makes the class more enjoyable for the students. 3) The assignments are well put together and don’t leave you guessing at what direction to go in. 4) The lectures are interesting and align with the assigments (Why this isn’t the case in other classes is beyond me).

Cons 1) Lectures could be updated

I loved this class, learned a lot and felt it was a good balance in terms of amount of time needed. I truly hope they don’t make any major changes to it going forward, minus updating it over time.

A good course on Software Development Process techniques. The course helped me practice git skills. I also learned basics of Android development and unit testing. Unit testing concepts were explained and the class design presented a very good example of how Test Driven development should happen in Industry. Professor Orso responded to each and every message posted on Piazza quickly. TA’s responded quickly to questions/concerns on grades in timely manner.

As with every other OMSCS course, it really helps to get started with assignments early. It could be tricky setting up group meetings if everyone is in different timezone, but if you are proactive enough all works out well. Good luck !

I came in without any Java or programming experience, so I had very hard time figuring things out. If you are new to Java I recommend 6310, but if you already have some knowledge, then the material is too fundamental for you. Assignments are due each week on Friday night which is silly for group project, especially if you are in different continent. Fun and knowledgeable instructors and helpful TAs.

If you’re reading comments that this is a ‘cakewalk’ of a course, understand that they’ve upgraded it considerably so unless you already have many years of professional Java and Android app development, you might not do well in this course. Unless you get a sucker in the team project doing all the coding and you become a Java wizard by the semester’s end. I was the sucker in my team so yay, me. Who needed sleep for a week anyway. Other than the team app issue, the course overall is a great course if you have never worked on code at a bigger scale before. And this course has the only Professor I have seen that answers all questions(private or public) on piazza, you really do get your money’s worth in this class.

The only people finding the course boring are those in the industry already with many years of experience or those that pay or get someone else to do the work for them. There is a lot of that as there are no tests, only assignments and some students do not even know basic java; but somehow pull off completing the entire final assignment(which is very difficult as you do not get to see what the inputs are) on their own in record time. It’s really annoying when others do better than you by cheating after you put in serious time and effort, but that’s life.

Pros:

• The course material is not very difficult. If you watch the lectures and read the instructions for the assignments, you should do fine. Programming tasks deal with relatively simple things like string management and test cases. This course is ideal for a summer semester because of its low stress level.
• Professor Orso is extraordinarily responsive and thorough on Piazza. I thought Joyner’s classes were organized, but Orso gives him a run for his money. You definitely don’t have to worry about getting messed up because of a problem in the course content.
• The individual project is somewhat fun. You end up having to reverse-engineer some text-handling code and write test cases for it. I liked it because I have little experience in Java (the language for most of the assignments), so I learned a little there.
• The lecture videos are a bit dry, but they don’t waste your time much. I didn’t mind watching them. Because there are no exams, there’s no need to take detailed notes, so it’s more relaxing.

Cons:

• This course has a strict assignment release and due date schedule. Assignments are only released the week they’re due, and if you finish early, you just have to twiddle your thumbs while you wait. In another course, this could be a major problem, but since the assignments were never too time-consuming, it ended up being okay. Still not preferable.
• There is a group project. Simply having a group project is a significant negative, since you never know who you’ll end up with, and there’s no option to just do it by yourself. I got lucky and got a decent group, but I’m sure some people weren’t so lucky.
• The previously mentioned group project is designing an Android app. That’s kind of a pro for me, since I’ve never done something like that, but it ended up being a con since Android Studio was unbelievably slow and hard to develop in for me (maybe a problem with my machine?). I also thought it was kind of a shotgun blast of new info that I’ll never use again, so not much stuck.

Overall, this is a low-stress course where you probably won’t have any eureka moments, but it’s good for strengthening your foundations and perhaps exposing yourself to Java and Android. It’s perfect for a summer semester or pairing with another course.

The other reviews for this class are pretty much spot on. The material is pretty foundational, and if you already work as a software engineer then you likely already know the material pretty well. If you don’t then you will get a lot out of the class.

I am a career changer, and a full coverage of software processes, notably unit testing and formal design, was very helpful for me. The group project is a crap shoot, I got a really good group and learned a lot about Java and about Android programming. A bad group would probably have made the experience worse, so be aware of the possibility.

The professor is an absolute workhorse, answering questions on Piazza constantly and always with a friendly and helpful demeanor. I cannot speak well enough of Dr. Orso.

I think this course should be taken in a Spring or Fall semester, but if you are willing to put in the work during the summer, it will be a little hecktick but is doable. I took it in summer and this class is perfect foundation. Only drawback is that you will have one of the highest grade valued assignments (and riskier ones as well) due at the same time of your team project. That caused me to have 2 deadlines at the same time. I had only the weekend for that assignment. I didn’t do well and that cause my grade to go down. I would like to say this would’nt happen during spring or fall, I think this could be avoided but maybe is an experiment to see what students do, since that is how real life in the SDLC things would occur. Now there is also an Individual Project worth more that the team project, and is also very tough.

Other than that. the course is excellent. I am a black box tester for a living, and I got benefits from this class. I learned Java coding, Intellij IDE (which is awesome!), Java’s JUnit 4 for unit testing your code, Android development in Java (some people I heard that coded in Kotlin which worked fine cause you can convert to Java so that is an additional skill you might learn), I also touched Espresso to create an automated test suite for Android, I also learned SQLite in Java for android, Git/Github in a team setting, plus all the formal documents for delivering and shippoing a project: Design, Project, Test PLan, and architecting the project using Lucidchar by creating UML diagrams, etc

More in git, I also beefed up on GIT/Github but collaborating with multiple team members all coding on the same files as you is very different from just you modifying a codebase on your own. So found myself using squash, cherry picking, and addressing rebase in both local repo and remote repo.

The professor is super active, and the TA team was excellent, Kudos to Q. He was active in both Piazza and Slack. I learned a lot. I just wish Assignment 5 was not worth that much.

Have to say this class is not easy but is worth taking for the skills you will get.

SDP Summer 2020. This class was good for me. If you read the reviews here you should know that this course isn’t too useful if you already know the material. Most of the negative reviews seem to be from people who didn’t read the reviews and expected this course to be something it isn’t. For someone like me with no software development experience, and who also didn’t major in CS in undergrad, I learned a few basic/useful things. I had a decent team for the group project and I feel I learned from it. I learned some Android basics and brushed up on my Java basics. I also learned some basic terminology and SDP concepts and I feel less clueless about those now. Some people complained that Assignment #5 was worth too much of the grade (20%) but honestly just be warned that you need to triple check your logic on that assignment and it’s not tricky. The professor was very involved in the course on Piazza. Overall worth taking if you don’t already know the material.

As a developer, I found this course extremely easy and I didn’t like it. I was bored out of my mind the vast majority of the time. It was cool that we got to use Android Studio (my job is cloud based) but the material covered is of a middle level undergraduate class. You’ll learn the basics of git, UML diagrams, and the software development process. The group project can easily be done by one person as well. My team was good and I did 99% of our back-end while others handled most of the UI and documentation.

The instructor, Alex Orso, is awesome though, and the only reason I didn’t give this class a strong dislike here. He’s very active on Piazza, admits when the autograder is having issues, and is very enthusiastic about teaching. The only thing that irked me is that he releases assignments on a Saturday morning which makes exactly zero sense. Just release on Monday and give people the weekend they want, most of us work full time! But anyways, if you can write code, you’ll probably get it done on a lax work evening.

I regret not pairing this class with something else.

This course started out initially with good expectations but got diminished as the course wrapped to a close. Frivolous software requirements and unforgiving six day deadlines made this course a chore.

Unless you are taking this course to either meet a specialisation requirement or needing to learn Java and Android programming, I would not recommend it.

Easy A class. No quizzes or exams or white papers, all practical, what I liked the most. If you want to get into coding game, definitely take this class.

Easy course, but requires that you dedicate time to it. You will need to complete an assignment/project every week. Piazza is a bit of a mess due to the huge amount of posts by students, but the TAs catch up very well and answer everything. Some assignments don’t have a clear rubric, so you really don’t know how you have done until you get the grade. Grades take sometime to be released. I have learned a lot from this course. I strongly recommend it and you can get an easy A on this course if you put sometime into it.

The content of this course is really easy, especially compared to some of the more difficult and math intense courses in OMSCS. Even if you have no Java experience, it should be relatively straightforward. As others have mentioned, there are no tests and the Group Project can be done by yourself, if you absolutely have to. I found the introduction to making Android applications really engaging and interesting. If you have no Java experience, I suppose it’s a fine introduction to Java.

However, the way the class is run and graded makes this course significantly worse than it could be.

1 - The grading times are LONG! On average, it took us a month to get an assignment returned to us. Some assignments took a lot longer. 3 days after the last assignment was due, I still had 40% of my grade missing. I find this unacceptable. If you can’t grade the assignments in a reasonable amount of time, get more TAs or simplify your assignments to allow them to be autograded.

2 - The TAs refused to give us grading criteria or a rubric. Whenever they were asked, they would respond as though the grading was obvious, but providing a simple rubric for each assignment would have reduced the Piazza forum questions by about half.

3 - The TAs were inactive on Piazza, and when they were there is was generally to answer easy questions that the students had already answered for them (quoting assignment or syllabus text to the person asking). If you had a more difficult question - crickets until a day before the assignment was due.

4 - HW assignments were released Saturday morning and have them due Friday night. I don’t know why they couldn’t have just overlapped them so you always had two weekends if you needed it. They said this was because the TAs could better respond during the week, except they never responded anyway and everyone worked on it over the weekends (obviously…) and there was little clarification or involvement from the TAs. This meant I was finishing my HW on Saturday then hanging around following the convolution of Piazza threads for the rest of the week and then frantically adjusting my HW come Thursday or Friday.

5 - The grading weights make no sense. A group project that takes about 60hrs over the course of 4 weeks was worth 20% of my grade. A simple Java application that I wrote in 2 hours is worth 15%.

6 - As a general course feedback note, for all classes really, PLEASE ORGANIZE YOUR PIAZZA THREADS! Man, forum posts get so out of hand so quickly. All it takes to make it easier to follow is to create a dedicated HW1 thread, or a dedicated HW2 thread…Then students only have to follow one thread and it’s far easier to see what has already been asked.

All in all, I soured on this class really fast. I thought the assignments were super contrived and convoluted, and I thought the grading policy was intentionally opaque to try and milk students for points. Worst OMSCS experience to date.

This course, in the beginning, was very good, but towards the end, it fails terribly at multiple things.

Pros: Assignments were fun and I learned a lot from Android studio etc..

Cons: Group projects are horrible. 2) The Individual Project is so vague and complex. Who writes frames and who even does black-box testing in industry? So, in general, the projects are horrible.

The ending of this course starts to become dreadful from how horrible the projects are. Start off strong so you can afford losing points towards the end of the course.

Would I recommend this course? Probably not. It’s a ton of work and not forgiving. Assignments are due 7 am Saturday morning EST time. Why not just extend it for a day? People have work. This course made me hate the program so far.

Literally my second year undergrad Java class. I would say this course is mainly targeted for students who don’t come from a Computer Science or Software Engineering background.

If you have Java experience of some sorts, this course would be a free A for you.

The name of this course should be Ambiguous Software Test instead of Software Development Process. There are 5 formal assignments besides Survey and Github usage, and 3 of the 5 are tests. And the whole individual project focuses on testing. Assignment 6 uses a tool named ‘TSLGenerator’ invented in 1989! I think lots of students are younger than it. Deliverable 3 of the project asks to write test cases to cover 100% of the classes which are invisible to us. It made me like a robot when I spent several hours on trying all the combinations to achieve the goal. What is worse, the whole course is ambiguous. The descriptions of assignments are ambiguous. Most of topics in piazza are discussing the meaning of assignments. The TA (if not a forum mediator)’s answers are ambiguous. For example, a student’s test cases cover 98% of the main class and he/she wants to know the weight of the other 2%. “You can get partial score”. Do you think this kind of answer helpful? The comments of assignments are always ambiguous. I got one line comment for most of assignments even I lost lots of points. I have to say this is the worst course I have taken from this program.

I would say this was an easy course. Since it was during short summer semester, there were submissions every weekend. For this course, the submission was every Friday EOD rather than Sunday EOD like other courses. If you are familiar with Java, this course would be easier. I would say this is a recommended easy course to take as the first one.

Nice and easy class. Easy that is if you already work in software. Teaches the basics of git, some basic architecture. Some of the materials are a bit outdated. I found a bit too much emphasis on the UML diagrams. But it still helps you to think about how the software works, even if nobody uses UML nowadays. Professor Orso is absolutely amazing. He is very responsive in piazza and any criticism that you have. This is unfortunately not the case in most other classes (Isbell in Machine Learning being the absolute worst).

By far the most disgusting course that I’ve ever taken.

• Assignments are released exactly 7 days before the due date, so if you are planning any trips or have a life forget about doing things or getting ready upfront… because they will make you suffer.
• Assignments have no rubric and TAs deduct points however they want. If you have good programming background, be prepared for long discussions or just be okay for B (I chose to get B instead of discussing every time a grade is released)
• If you have no Java background, avoid taking it without practicing before. All assignments are in Java
• Assignments other than group and individual project are not related with each other.

Overall I think this class was a good intro to the program if you don’t have any experience in programming at all. Otherwise, you may see it as a waste of time, especially if you studied CS in undergrad or work in some type of software development role. The lectures were a bit stale, but overall the assignments weren’t difficult. The one thing I didn’t enjoy about the class was how slowly we received our grades back, so hopefully they’ve improved on that front since I’ve taken the course. Otherwise, in terms of the group project, as others have mentioned it really is just a hit or miss on how good your group is. My group was great, but some did not have as great of an experience as me. Note: We weren’t able to pick our groups.

Great course! Very useful for someone who doesn’t work in software development and provides a good overview of git, code testing and some other useful tools used in the field. If you do work in the field, i would probably shy away from this course unless you want a very easy A.

Lectures are fun and well put together, the professor is clearly passionate about the subject matter and is fairly active on Piazza. The TA’s were also very good and were helpful with clarifying assignment instructions.

The course had 7 Java coding (or mostly coding) assignments, 1 individual project and 1 group project. The group project can be good or bad depending on the team, but it could be done by one person in a pinch. This project is more about documentation than it is coding, so make sure to document everything exactly as it is described.

Pros: Very easy course, lectures are a little dry but covers the TDD framework well.

Cons: Very slow pace, lots of busy work for group projects, grades take forever to be returned, too easy for a graduate class from GT.

Easy course. Nice lectures and easy projects.

This course was pretty easy. It was a great way to unwind after taking the brutal Reinforcement Learning. However, I felt like I learned a lot in RL, but not as much from this course. The assignments were pretty easy, but felt more like busywork than an opportunity to learn. The lectures were pretty good and made me reconsider some things about my job. The professor is great! Piazza was a bit crowded with people asking questions that had already been asked several times, so I started ignoring it. The workload wasn’t too bad, even for the summer. My group was very proactive so we met more than once a week and we did pretty well on the assignments.

Unfortunately, I had taken the Software Engineering course 6310 before this course. They are extremely similar, and so I felt like I had already learned about 70% of the material. That being said, I wish I had taken this class first, since I liked it a lot better. SE is focused on UML diagrams. SD is focused on the process of creating good code more than its structure. I feel like that was a much more useful approach as a software engineer. So I’d recommend taking this class and skipping SE.

Coming from industry this ended up being a pretty boring course. There weren’t too many assignments and only a couple projects. Many of the assignments just felt like busy work though and because of the limited instruction in the class I think those not familiar with Java and Android development will struggle a bit.

If you are coming from a non-CS background, I would suggest this or GIOS as your first course in the program. This course is a great intro to software development in Java and Android. The concepts and techniques of the course are applicable to any OOP language. The best part of the course was developing a functional Android app in a group. While the groups are set up such that you will have one expert on your team, each team member will be able to contribute. The project is meant to teach the Agile development process including test driven development. I was not thrilled with the emphasis of using the TSL generated tests, but understand why they would want to teach a formal method. The instructor and TA’s were great with responses and support for such a large course. My main complaints are the lag in feedback (grades) considering the individual projects are cumulative and the summer schedule is not balanced well. One week we had two major deliverables due (one group, one individual). You can’t really work ahead either. Still, a valuable course for any non-professional Android programmer.

This was my second course in the OMSCS program, and it was pretty meh compared to the first one, AI4R. Not having a CS degree, I thought it would help me get some experience in Java, OO, testing and the like. While it did help me in those areas (especially testing), I thought the depth of material wasn’t enough for a graduate level course. I wish OMSCS offered a course that contained the material from this course as well as other important topics as a CS refresher for people with no CS background. I also wish that they replaced the group project with a semester long individual project that covered these topics in practice.

Great class. The instructor is highly engaged and very passionate about the topic. Being comfortable in Java and git are very important. Also learn basic regular expression and Java matcher APIs. Besides A7 (white box testing), I found all other assignments to be quite straight forward. There were 7 individual assignments, one group project, and one individual project. Assignments 5, 6, and 7 takes makes up majority of the assignment grades percentage wise.

Group project grading is strict, so pay very close attention to the project description (and the deliverables for each week). Group members are randomly selected. I unfortunately ended up in a bad group. However, the group project is basically a simple android app (ended up writing around 4k lines of code total). One person can do the project by themselves but it will be quite a bit of work.

The individual project was very simple. It did not take much time.

During the summer term, the load is a bit higher due to having multiple deliverables during the same week. There is something due every week besides the first week and the last week of classes. So if you are planning to take it during the summer, make sure you are very comfortable in Java, Regular Expressions, UML (class diagram, use cases, sequence diagram), jUnit, and Android app development (especially dynamic UI content generation, persistence via SQLite or Room). Otherwise the summer semester might feel hectic and rushed. I traveled 5 weeks out of the 11 weeks in class and was able to manage it fine during the summer.

Not a bad course. Teaches a lot of essentials for software engineering. The problem is that project group are randomly assigned. It will be pretty difficult if you are the only one or two working on the coding part of it.

This should be a class in software engineering. The class is pretty popular because it’s required for the Interactive Intelligence specialization, but it doesn’t teach a lot of good software engineering principles, in my opinion. The way test-driven development is explained and required in assignments is a bit bad, so I recommend you don’t take the class recommendations blindly. The video lessons are actually decent, but the principles aren’t implemented soundly in the assignments, the rubrics are often subjective, and grading is painfully slow. But the pace of the course, with weekly assignments and a group project, makes it hard to front load and/or handle the projects in a way you see fit.

Recommendation: if you’ve already got some software development experience and you’re not doing the II specialization, skip this class. If you’ve got zero software development experience (e.g. you’re switching careers), this can actually be useful despite its shortcomings, but in that case a) make sure to learn some Java beforehand and b) don’t take the class during the summer, because the schedule can be challenging for a newbie.

I really enjoyed this course. I felt the information for useful in my daily job. We wrote the group project in Android, which is one of my favorite platforms. The other projects were in java, which i was already very familiar with. The development was done using IntelliJ, that was new to me but it seems like a really nice IDE to use. We also gained experience using GitHub, which was first for me. This could be a first course but probably better as a second course to take. The TA’s do take a while to release grades, so be patient.

Took CS6300 in Summer 2019. I think because of the shortened 11-week summer semester, there were some time crunch weeks where you would have both a HW assignment due along with a non-trivial Group Project deliverable (weeks 7 and 8). Whereas in a regular 16-week Spring or Fall semester, those would be spread out so there would only be one HW assignment or one Group Project deliverable. Also the Summer Individual Project Deliverables 2 and 3 are crammed into one week, albeit with the combined Deliverable 2 and 3 abbreviated a bit compared to the Deliverables 2 and 3 on separate weeks in the regular semester editions.

Other than that, having a good group will help a lot (but your group is chosen by the TAs to take into account experience/skillsets/time zones so all you can do is cross your fingers).

You can’t work ahead because the HW assignments and Project Deliverables are released on Saturday morning and due the next Saturday morning (if you are in a US time zone). So forget about taking a vacation from mid-May to late-July, especially if you are also working full-time.

I did well (ended up with over a 100% in the class due to some small extra credit in the Individual Project), but this class took more time that I thought it would (a little over 14 hours a week) because I was in charge of releasing the deliverables for my group and am sort of a perfectionist. I have a little Java/C++ programming background, but that was mainly in an academic setting back in college (never professional) a long time ago in a galaxy far far away. So to be honest, I forgot most of it. I had to pick up Java and OOP real fast and needed to spend a little more time working out how to use Intellij and Android Studio. It wasn’t that hard, but I did work as an engineer in a professional setting coding logic in other languages.

I had a pretty fast computer – recent Core-i7 desktop class CPU, with 32GB ram and a PCIe SSD running Ubuntu Linux, so using Android Studio to run various on-screen Android smartphone emulators was pretty fast and smooth for me (took about 4-5 seconds to start up an emulator to the home screen), so I didn’t have to sideload our group app to my smartphone to test it. I’m not sure how long it takes for people on “regular” laptops to startup and load an Android emulator from Android Studio. I just sideloaded the app in the end to make some final QA checks; and that was pretty cool to see your Android smartphone running a crypto text game successfully and not crashing =)

All-in-all, a fun class, but one that took more time than I anticipated for the summer. I got some good value from the class, but I’m not a grizzled SW engineer much less a SW engineer at all. This class is more backloaded in terms of work in the summer – the first assignment is just a team matching survey, following by 2 coding assignments (git repo manipulation through the command line and Basic Java coding). Each can be done in a weekend afternoon or less (maybe 2 weekend afternoons for the Basic Java coding). But the Android app assignment (week 4), the final Android Deliverable (week 9), and the Individual Project Deliverable 1 and 2 (weeks 10 and 11), I spent anywhere from 14-20 hours working on it for that week.

The only thing that you could work ahead in is the final group Android app deliverable, but considering how much it is worth (15% for the actual project, 10% for how your partners rated your work) and how it is graded, your time might be better spent just hitting the requirements and not endless optimization of the app and the layout/appearance of some button. More value is put on thorough documentation, hitting all the requirements/specs, and the thought behind the software design process rather than an aesthetically pleasing, 100% clean, efficient and corner-case bug free program.

As someone new to computer science, this was a great intro to how software development works (or is supposed to). As someone new to Java and OOP, the learning curve was somewhat steep but manageable. The biggest time sync was the android emulator when debugging my android app. I highly recommend you use a phone if one is available or even buy a cheap used one off eBay. It will literally save you tens of hours, which, if you value your time, is worth spending a little money on if you have to. If you already have a CS degree or experience in the field, it might not be as enlightening and your time is probably better spent elsewhere (unless you just want to take an easy course). As someone new to the field, it helped me learn to speak “software” and understand OOP. Java seems very intuitive once you get the hang of it.

There are lots of good reviews here already, so I will just second them. Good class. Instructors and TAs care. A little strict on grading but I can see why. I liked the group project (develop an android app over several weeks), but I had a good group. Could see why it would not be so good with a bad group.

You cannot work ahead at all as each week’s work is released only on that week. However, no tests is nice. Only projects. I recommend it.

Great refresher or introduction class for software development practices. Covers IDE setup, source control (git), UML, design, development, testing and working together as a group. You should be quite comfortable with Java before taking this course. Experience with Android will also help.

Work load is relatively light, but expect a significant assignment (or two) due every week with no option to work ahead. No tests at all which is nice. There is one group project, so hope you get a half decent group. Half my members were competent which was good enough to do well I think.

SUMMER 2019

Workload

• 7 short assignments (1 per week)
• 1 individual project
• 1 group project
• No tests
• Workload ramps up towards end of the summer semester, they pace you at 1 assignment per week, which has its pro’s and cons.

What you’ll Learn

You’ll get the very basics of:

• Git (and GitHub)
• Java
• Android devlopement
• Software development processes as well as do’s & don’ts

Other Notes

• Professor and TA’s were very involved, and have made a clear effort to keep the material updated.
  • Professor calls into every single office hours, so he is there if you need him!
  • The TA’s answered questions promptly, including a lot of (what were in my mind) self-evident questions on Piazza with almost no complaint, so props to them for their patience and thoroughness.
• Group project difficulty can really depend on your group members
• Lectures were very short and to the point, which was much appreciated, especially in this topic.
• Difficulty (for a graduate level program) was easy to easy-moderate. This course can be paired with another.

Overall, I didn’t walk away feeling inspired or wow’d, but the course met its objectives and dips into app development and Java which can be interesting if you’ve never touched them before.

The course was very straightforward. I never had to think too hard to figure anything out but I did gain experience with tools I hadn’t used before. The lectures were decent though if you’ve worked in software development, they probably hit on much you already know or have heard before. The forums were active and helpful. There’s a month long group project which I would suspect could make or break your enjoyment of this course. I had a great team and the project was fun so I enjoyed the course. Many of the assignments and the individual project are pretty abstract and a bit boring but also pretty easy if you’re an experienced programmer. If not, this would be a great course to gain some skills in that arena. My main complaint was grading and feedback. The grading was very slow and feedback usually wasn’t very helpful and it usually came so long after the due date (around 1 month) it’d be hard to remember what they were talking about even if it was more detailed. And the fact that many assignments built on one another makes the slow grading even more of an issue. I think the individual TAs seemed good but maybe they didn’t have enough of them to effectively manage the workload. Professor Orso was great, very involved and clearly enthusiastic about the subject matter.

Summer 2019 - 7 individual assignments, 1 individual project, 1 group project. No tests, but there’s a “participation” grade for watching all of the Udacity videos and taking the embedded quizzes. Assignments are well defined, questions are quickly answered. Good TA’s & really good Professorial interaction - he was active on Piazza, and in weekly office hours. For the content, fine level of concept coverage, some dated material, but it’s made up for by updates that are released in Piazza. Grading is pretty slow, so if you’re not confident you’re doing well, you’re going to have to reach out and ask questions and attend office hours to know how to fix your shit.

Easy but a super good class. The assignment is highly related to the video and well organized. Description of the project are clear.

The class wasn’t very focused. The readings and text and lectures seemed to jump around and not line up. I didn’t learn as much as I would have liked about software development. Overall you can get through this class without a lot of work if you already know Java fairly well. The quizzes are open book and the projects are straight forward. The hardest part was the group project, but most of the challenge came from working with others on the assignment.

Read through all the piazza threads, instructors clarified a lot of the assignments details there in comments.

As a full time software developer, I didn’t find this class very useful in terms of new information. I did find it very easy, and a good start to my OMSCS degree. I took CS 6035 at the same time and found both courses very manageable for my first semester.

There is 1 group project with 4 deliverables, 1 individual project with 3 deliverables, and 7 homework assignments throughout the course.

I got lucky in my assigned group and had someone frontload the project work due to their time constraints, while the rest of us spent each deliverable making enhancements. Obviously with group projects YMMV, but I chose this class mainly due to the ease at which OMSCentral rated it. I highly recommend this course as a first course to OMSCS, especially for full time developers.

This is probably a good course for folks with non-CS background like myself. Topics cover JUnit, Git, Android, Code coverage, Espresso, and all projects are in Java. The class projects were pretty simple and straightfoward, but there is a deliverable every week so it can feel overwhelming if you’ve got a ton of other stuff going on. There is a group project where you can work with 2-3 other people. Overall, I had a good time with this class, and really enjoyed it. I appreciate the exposure and experience considering my non-CS background.

The professor is very active in this course, which was refreshing compared to the other classes I’ve taken. The lectures are also much more interesting to watch as the professor is quite quirky. I do think if you’re someone who is already a veteran in software development, you might find this class to be non-value-added. Otherwise, this is a fun class and an easy A, as long as you keep up with the work.

My only critique is that the largest (and hardest) portion of this group project was essentially the programming part (we had to create XML layouts and design an Android app)–but the overall grade was focused equally with the other parts of the project, which was mostly documentation. I can’t confirm the exact division of points, but there were 4 deliverables, and 3 out of the 4 were documentation related. It definitely felt like 75% of the grade was paperwork, but only 25% was the programming (which was honestly the hardest/lengthiest part!). My group was pretty hardworking and we actually put a lot of hours into the programming part. We managed to get a fully functionally app… But we got ding’d for some misunderstanding of how to present the documentation, so that was a bummer. Word of advice, make sure you hassle the class/TA’s for clarification for everything that sounds ambiguous–I swear, sometimes it feels like they do it on purpose to trick you! The group project was worth 15%, than another 10% was the collaboration grade which was based on how the group rated each other. So in total, the group project is a quarter of your overall grade. Anyway, this is from my personal experience since I really lucked out with an amazing group, but I can see that the distribution of points is likely more than fair since the instructors want to account for cases where folks get a bad group.

I took this course as a less work intensive course to pair with a very high workload course. It worked out well. The course is not very demanding but there is something due every single week of the semester on Fridays. So be prepared to have to dedicate 5-10 hours every week of a 16 week semester to an assignment/project. Since I don’t come from a traditional CS or software engineering background the course content was somewhat interesting and entirely new to me. However, if you’re already an experienced software engineer by trade I doubt you will learn much of anything in this course. I think the course content is only enough for maybe half a semester and I wish there had been a little more substance to the course. There is a group project which is always a drag because not every member is as committed to the team typically. We had one of three of our group members who did next to nothing on the group project and we picked up the slack. They are pretty lenient on grading the group project since they know this can be the case. Java is required for this course. I didn’t have any prior experience with Java but I was able to pick it up well enough by dedicating a little more of my time at the beginning of the semester. If you already know Java it’s a breeze.

I had a little more hope for this class in that there would be more to learn. Half the course was spent with testing methods, which are indeed important, but we barely or didn’t cover other important aspects of SDLC, such as maintenance. I understand there is a second course that may go into that a bit more.

A great and perfectly managed course. The TAs are quite helpful and the prof makes sure that all the issues are handled proactively.

It’s a good introductory course to start with.

Professor goes very slowly each with one assignment and he start with the easy assignments.

Most of the assignments were easy but if you don’t know JUNIT testing then learn. (Individual project and two assignment is based on JUNIT) Also one assignment and Group project is based on Android app development. Other assignments are easy like make a GIT repository and draw UML diagram etc.

That will make the life easy, Else assignment deadline is every week and you won’t be able to finish the assignment.

If you are someone with a non-CS background, this class is probably a good ramp-up introduction to OMSCS, Java, Android, and some software development philosophies.

However, if you are a Software Engineer, have a CS undergrad degree, or know Java / Android this class is a waste of time. The class covers things like:

• git
• Basic Java
• JUnit
• Basic android development
• Documentation
• Testing

most of which you will probably know already, could easily pick up through some free courses on Udacity or YouTube, or is industry / company specific. And despite covering pretty basic stuff, the class is pretty time consuming with homework due every week, a group project in the middle of the semester, and very little flexibility on the part of the Professor. I would not recommend this class unless you don’t have a CS background or you’re looking for an easy A.

Great first class. It gets you up and running with github if you hadn’t experienced that before and exposes you to app development in android studio. Very helpful as an entry-level course into this program.

This course is super easy! I didn’t learn much and it was basically a repeat of course material I had when I was in undergrad. The group project wasn’t very useful either. The course is an easy A if you want it but don’t get your hopes up that you’re going to learn a lot; especially if your undergrad was Software Engineering / Computer Science.

Overall it’s a good course for software development introduction. The individual project is time-consuming, but no difficult. As for the group project, the teammates are assigned by TA, so you may end up working everything if the other teammates don’t have any android experience.

Great first class. It gets you up and running with github if you hadn’t experienced that before and exposes you to app development in android studio. Very helpful as an entry-level course into this program.

I thought the class was OK. I took it as my first class, but have since taken four others. The TAs ran it extremely well and had the best office hours I’ve yet seen in the program. Unlike other classes I’ve taken, Professor Orso actually makes appearances on Piazza and in the office hours, and it’s nice to see some actual involvement in the class. This is a very useful class if someone is in the program to make a career change and doesn’t have a software background, but someone with existing experience in the field won’t learn much. It is, however, a nice class to get accustomed to the format of OMSCS, as the first several weeks have a very small workload.

The group project is hell. It was a ton of work compared to the rest of the class and is a very jarring transition. Making matters worse is the fact that I am in the Eastern time zone and was paired with teammates in California, which made meeting as a group tough. During the four weeks of the group project, I was probably working 15-20 hours a week on this class, with the rest of the semester being no more than 3 or 4 hours per week. I will note, however, that I got paired with a very gung-ho group who went very above-and beyond the requirements for the app. You can probably get an A with a lot less work than what we put in, but that’s going to depend on what kind of group you get. Obviously, my situation is preferable to the opposite extreme, but it was a rough few weeks.

Besides the group project, I enjoyed the class. You won’t get any frustrations coming form a lack of structure or organization and it serves as a great intro to OMSCS in general. It’s also nice as it’s one of the few classes other than GA that counts toward multiple specializations, so if you’re on the fence between Interactive Intelligence and Computing Systems like I was, it would make a really good intro to the program.

This course is well-suited for entry-level students in OMS CS. You learn about how standard software development processes are applied to create Android apps using Java. Do NOT take this course if you have already taken DB Systems, as they do share a number of similarities (though they are not the same).

Summary
This was my first class in the program. Very light, easy class. Good as a first class or to pair with another.

My Background
Software Engineering with less than 1 year of experience. No undergraduate or graduate degree in Computer Science. Use Java & Github at work daily.

Estimated Workload:
~5 hours per weeks, maybe slightly more during the group project.

Summary of assignments

1. Github Basics - Follow a set of instructions.
2. Implement a simple Java function and write test cases.
3. Code up a simple 1 screen Android app with a few buttons and basic logic.
4. UML diagram for an app (this ends up being the app in the group project) (no coding)
5. Group project (over 4 weeks, 1 deliverable per week) - Vocabulary Quiz App a. UML diagram (no coding) b. Documentation - Design, Functionality etc (no coding) c. Test cases & basic app (coding) d. Final app (coding)
6. Write test cases for a black box app (no coding)
7. White box testing - Given a few scenarios, identify which white box framework they fall into.
8. Individual project - Code up the black box in part 6. (over 3 weeks, 1 deliverable per week)

Takeaways

1. Read the instructions in assignments very carefully. You can easily miss points for silly things like mislabeling etc.
2. Assignments are released every Saturday morning and due the following Friday. Many students complained about this but I actually liked it. Use part of Saturday/Sunday/Monday to work on the assignment (each homework shouldn’t take more than 5 hours). Use Tue/Wed/Thu to monitor Piazza, watch office hours, and make any minor changes. Submit the assignment on Friday.
3. Both projects are pretty easy. Even if you get a bad group for the project, you can probably code up all of it yourself in under 20 hours (over the 4 weeks, so 5 hours per week)
4. Office hours once a week - professor shows up along two head TAs.
5. Assignment grading is slow, usually more than a month to get grades back.

Android Resources

1. Learn how to set up buttons, user input, and sql lite databases. Skim through these resources. The 3rd assignment will also give you some experience with basic Android.
2. Udemy ($10-$12) - I went through the first 1/3-1/2 of this course. (https://www.udemy.com/the-complete-android-oreo-developer-course/)
3. Udacity Android Basics: User Input (https://www.udacity.com/course/android-basics-user-input–ud836)
4. Udacity Android Basics: Data Storage (watch the section on SQL light) (https://www.udacity.com/course/android-basics-data-storage–ud845)

Was an ok class overall. It was truley only the group aspect of the course that caused the most grief as it leans itself into potentially forcing one team member to carry the others.

Fall 2018

If you have software development experience this class is quite easy. It consists of watching lectures, attending/watching office hours, doing weekly assignments (most are programming but some are design), a group project, and an individual one.

Structure

• Weekly assignments
• Group project
• Individual project

Pros

• Good introduction to software development practices.
• Relevant to today’s professional development.
• Good emphasis on Test-Driven-Development with multiple assignments focused on this.
• Assignments were interesting and very manageable.
• TAs and professor were very active and involved in the class.
• Group project team mates pulled their weight and the app was quite interesting.

Cons

• The biggest issue I personally had with the class was that some assignments felt like busy work. Given that we had something due every Friday, it seemed like some assignments were put together to just give the students something to do.
• Having deadlines on Friday (early Saturday morning in the US) caused some scheduling conflicts. The professor defends this practice by saying that this encourages students to start the assignments early and discourages procrastination.
• The grading is very slow and tends to lag behind anywhere from one month to two months.
• Group project team mates are randomly chosen based on a survey which can lead to widely different experiences.

Overall this is an easy class for someone who has professional working experience. Other reviewers have mentioned that the group project is quite bad, however in my experience I was lucky to have good team mates that pulled their weight.

This course is a good one for those who want to be a software developer. The course includes knowledge about how to develop software, how to use git, how to cooperate with teammates, how to test etc. Overall, this course gets me familiar with the development process. If you are a software developer already, this course may be too easy for you. The TAs are helpful, but the course videos are boring.

This was a very good first course as the workload was light and not overly challenging. I think it also taught a lot of good fundamentals of software development, such as agile methods and testing. I liked the office hours format - students would submit questions ahead of time, and the professor and head TAs would discuss on YouTube. Very helpful! My only complaint was that grading was very slow, which could be frustrating. Overall though, I definitely recommend.

Pros: Coming from a non-software background (mechanical engineering undergrad), I think this was a great intro course to software development. I STRONGLY suggest taking this class with another course (saving it to pair with a medium/harder class). All the topics were very relevant and applicable to work (as a software engineer). Android project was my favorite although it is nice to have some teammates on your team that know a thing or two about android app development, and can meet locally. NO EXAMS, only assignments and projects. Super relaxing in terms of the grading since no need to stress over exams. As long as you do the assignments properly and on time, you’ll be ok.

Cons: Homeworks are released every Friday night and due the following Friday night. It can get annoying since its hard to work ahead if you have something in particular that you want to do for that week/weekend or manage your time in a more flexible way. Some assignments take less time and others take more time… so your week is kind of “up for grabs” depending on the assignment, makes it hard to schedule other things in your life (depending on what your priority is of course). TA’s are a bit hard to get a hold of, and grading takes a while.

My first course. It was hard for me since I had little programming experience. I spent 20 hours per week. There were homework every week, a group project and a individual project. I was lucky enough to get an A.

Recommended as a first course especially if one doesn’t currently work in the industry. Most of the assignments were straight forward and in Java. The worst part about the class was, yep you guess it, the group project.

Two of our group mates spoke broken English and pretty much went missing in action for the duration of the project until the last week. They tried to help with app documentation, but they had no idea what was going on. At this point it was better off that they didn’t help at all. This course taught me how to hate group projects where the course randomly picks your teammates. I had a great time in IHI and EdTech, but SDP was truly one of the worst group projects I have been in.

The group project should have taken 7-10 hours a week but my teammate and I ended up doing about 20 hours to carry our other 2 groupmates.

The professor is clearly passionate about a specific topic that is part of the course, software test. Therefore, in my opinion, there is too strong of an emphasis given to it; while some other topics of SW process are not even mentioned (code review is one that comes to mind). Especially since there is another course that is focused on SW test only. Didn’t like the TAs. The vast majority of the Piazza replies from them were single sentenced referring students to other posts, even though they could clearly add more value to the topic if they bothered spending more than 5 seconds on the response. This is usually a reflection on the importance the professor gives to the course and the students.

It would take an average of about 8 weeks for grades to come out. Which makes even less sense when the quality of the feedback given is taken into account. The TAs could easily be replaced with auto-graders as they clearly followed a very strict (and obscure) rubric with no variations/exceptions and provided no feedback on the assignment other than “great job” if you got 100% or three-word sentences referring to a rubric that the students don’t have access to when you got something wrong on an assignment. Flat out ridiculous. This created a fabricated level of difficulty to the class, which I think they realized later in the course and gave the opportunity for a 20% extra credit on the individual project for something that was supper easy to obtain.

Even if you are going through this program only for the degree and care very little about what you learn; save your money by selecting something else. There are other courses that offer an easy A but are not as wasteful of your time and money as this one.

A great course. Prof. Orso is a great instructor, and is hilarious. I was fun learning how to create an Android application (both for the group project and individual assignment). The course truly strengthened my skills in Java.

I have 2 slight complaints though: 1) I would have liked to learn more about common Java frameworks (Struts, Sprint, Groovy, etc.) 2) The TAs did take a long time to mark the assignments, however, they were very generous when it come to re-grade requests.

I would recommend this course as a first course for the OMSCS program.

Overall, this class felt like a waste of time/effort. Again we have the requirement of a group project, this experience wasn’t bad, but it does add unnecessary difficulties. I work 40+ hours per week, and have a family as many in the program do; the way I make this work is that I have to adhere to a pretty strict schedule…I go to bed early and get up early, but now with group work, I have to change schedule to meet up and do work at a time I’m pretty much dead to the world. For working professionals, this is a ridiculous requirement; I can only assume the main motivation behind group work is so that there are fewer projects to grade. As another reviewer mentioned, the grading was glacial in this course; 6-7 weeks to get some grades back. There is no possibility to learn from mistakes and correct before making the same mistakes again. Also the UML portion felt like a complete waste. I took the course as a requirement, if you have any experience you will likely learn little to nothing.

I had mixed feeling about this course. As a new student, I carefully choose a not too hard course to start. This course gave me a little trouble in the beginning. For one assignment, I was one day late due to a late start and a seemingly easy issue that I can’t get correct answer in piazza discussions. I struggled with this little problem until finally the professor pointed to the issue. I fixed it and submitted the assignment, but got half credit. I did feel that one of the course video is misleading that caused this mistake. Like some others have pointed out, you will be surprisingly got a low score for some unimportant minor things. I got a low score for another assignment, and even wanted to withdraw the course. Luckily, I stick to to it, and scored a lot better in later assignments and projects. I admitted that I learned a lot from this course, git, java, android, some database UML, whitlebox/blackbox testing, and most important of all, never give up. Eventually, I got A despite some mistakes or unfortunate situations. It’s good experience that I suffered in the beginning, while enjoyed at the end.

Background: studied software engineering in undergrad and work as a developer, so I just took this as an easy class to pair with ML4T.

The class isn’t bad, but I’m not sure I learned anything new. The assignments were very easy, but the group project did take a little bit of time (so roughly halfway through the course was the heaviest period). Unless you’re a pretty inexperienced programmer or want a very easy semester, I wouldn’t take this course on its own.

Overall an easy class however grading is slow so you go through most of the class without any idea of how you are doing. Basically, if you’re doing something wrong, by the time you get your grades, its too late to fix it. Also, grading is really petty. If you do 99% of the assignment right but a few small details, they mark off like 50%. A large portion of the group project grade is based on whether your group members said you contributed. Me and another group member did 95% of the group project work through out the project but because other group members scrambled the night that it was due and we didn’t, they said that we didn’t contribute. Overall it was a decent class but I wouldn’t recommend as your first class because it might turn some people off to the program if they thought all classes were this disorganized.

An excellent class to begin OMSCS - but caution should be thrown to full time devs - you probably know quite a lot of the things being taught.

For non-devs, this is absolutely essential in understanding the software development process, collaboration, testing, version control and even Android mobile development - which depending on your classmates is a lot of fun or a lot of stress.

If you don’t know anything about software engineering, taking this isn’t a bad idea.

If you’ve ever worked at anywhere remotely serious about software engineering than this isn’t a course that you’ll get anything out of.

This is a good overview for software development. If you have been developing for a while using modern practices like Test Driven development and Agile, it may be a repeat; however, for anyone with limited development experience this is a great course to get you ready for development in the industry.

My background: Majored in Mechanical Engineering, knew how to code, but by no means an expert, best language python, never coded in Java or Android Studio before

My thoughts on this class: Sometimes I felt like I wasn’t learning much, and the weekly assignments were a lot to deal with. You have one week exactly per assignment, and no more, which for me made this class tough to pair with another. As soon as I finished an assignment for SDP, I’d try to work on class 2, but wait! There’s already another assignment due for SDP. That said, it’s a solid first course to get into the groove of the program, I did learn some stuff about, well, the software development process.

Class Structure:

• Weekly assignments, due on Friday nights. (Saturday 5am in California Time)
• 1 group project that spans 3-4 weeks, a part due each week. 3-4 people/group. Involves building a simple app with Android Studio. Having never done this before (but having made a few very simple iPhone apps), I found it to be not that bad. I dislike Android Studio, but I managed. Toughest thing in the whole class is implementing a database on Android Studio for the group project, but thankfully someone else in our group did this. Documentation is important for group project.
• All other assignments are weekly and done individually. Instructions are very clear and must be followed to the letter, in a sometimes annoying but ultimately helpful way. All assignments are very doable for novice coders. If you can make an if-else statement, you can pass this class. Having never coded in Java before, I survived, though with a healthy dislike of how Java deals with Strings!

Final Thoughts:

• Good first class. Take this class first, and don’t pair it with another class. The weekly assignments makes the pace of two classes too stressful. Also I didn’t like that the assignments were released Saturday morning because I don’t have access to a printer at home. I would drive to work on Saturdays to print. Not fun. -Sometimes I felt like I wasn’t learning anything, but only later did all the assignments come together. Overall glad I took this class to bring me up to speed on a lot of CS terminology I wasn’t previously aware of (White/Black box testing, UML diagrams, etc). As I transition from mechanical engineering to CS work, I’m finding the terms I learn in class constantly pop up. Ergo, this class is doing something right. -Watch the videos a week earlier than listed on the syllabus so you immediately know what that week’s assignment is about. -Teacher + TA’s were great, always on Piazza.
• If not for the weekly assignments, I’d pair this class with another one. I tried to, but ultimate dropped it because of the frantic nature of weekly assignments. Maybe double up the assignments and give everyone two weeks to do it?

Great First Course for OMSCS

This was my first course in OMSCS. I came into it with an academic background in mathematics, but my day job requires use of java. If you aren’t familiar with java, do yourself a favor and study up on it before the course. This course gives you a great opportunity to learn some java, learn how to use piazza, canvas, github, work with a team remotely, and just get the essence of OMSCS.

The first couple of assignments were straight forward and easy to complete. Once we started working with Android Studio, I had to do a lot of research to see how it worked, but was able to complete assignments working less than 10 hours a week. This time requirement went up with the individual project. I had a good group and our app was fully functional, but we put a lot of time and effort into it, up to 15 hours a week. I spent some extra time on the final project in an attempt to earn some extra credit.

Tasks are assigned and collected on a weekly basis. There is one assignment/deliverable each week. They are due on Friday 12AOE, which is Saturday 7am EST. There were no extensions and they will not release assignments early. Be ready to work each week. Professor & TA’s are very active on piazza and hold a weekly office hour on YouTube Live. Assignments were sometimes easy and sometimes challenging, but I was always able to confidently submit my assignments (except the uml diagram, but I got a 100).

Don’t expect grades to be returned in a timely manner. It took upwards of 3 weeks to a month to get grades back, though the grading always seemed fair, and they honor grade challenges.

I really liked this as a good first course, it taught me a lot about Java, Android development, and software testing. I disliked the group project very much - but only because my group couldn’t even seem to compile a program successfully. The assignments were very well put together and I felt challenging. The only thing I disliked is the TAs seemed to have really ridiculous grading - they would take a massive amount of points off for small things and then miss fairly large things.

I actually took (am taking this class on Fall/2018, but figured to give feedback sooner than later). If I ever invent the time machine; this is what I would do, in order of priority: 1) Change my SDP selection to another course in OMSCS 2) Try to prevent the biggest catastrophes in the modern world like: WWI, WWII, 9/11. 3) Buy shares of the following companies as soon as they became public: Apple, Google, Microsoft, Amazon.

Save your time and money and choose another class. I am not a CS person (I am an Engineer) and still didn’t learn didly squat on this course. Professor doesn’t give a crap; TAs give single-sentence answers to Piazza questions (don’t give a crap either); and, worse of all, there is a lot of busy work fabricated difficulty on the class that has absolutely nothing to do with the material announced at the course curriculum. These are the only reasons for you to take this class: 1) You want an easy A and absolutely don’t care if you learn anything valuable through your OMSCS time 2) I can’t come up with a second reason

My feeling is that this class was part of the initial GATech push for OMSCS; before it got its chops, and GATech was begging any/all of its professors to turn any material that could be turned into classes.

Use your OMSCS time wisely.

This was a great introduction to the OMSCS program. It teaches you the basics of what you will need to know through out the program. Its not a difficult class so you have time to acquaint yourself with all the different technologies used in OMSCS as well. There is a group component to this class. We filled out a survey and the instructor or TA’s paired us up. There are 3 group projects and 6/7 individual assignments. There were no exams. The class uses Java for all of the projects. 1 project was a very basic Android app. You should at least have a basic understanding of Java so you can help your team in the projects. The professor held weekly office hours and was actually pretty active on Piazza when I took this class. In my opinion, I think this professor ranks as one of the top professors in the program. He deserves a bit more recognition. He has an ability to break thing down and make them seem so simple. If you’ve been in development for very long, you realize how valuable that is.

For the experienced developers:

If you’re already a software dev then you may find this course lacking new information to you. If you still want to take this class even with experience, know that not everyone is on the same level as you. This could be a chance to learn patients and leadership. It may also be a good opportunity to gain some practice in mentoring people new to the field or subject. Also, if worse comes to worse, and you end up on a team that doesn’t contribute at all, all of the projects can be done by one experienced developer quite easily.

This should be everyone’s first course in OMSCS.

It’s a survey of software development and working in teams. You learn about unit testing, Java, IDE, and UI basics, git and github, and UML design.

If you have an undergrad in computer science this course is easy but still managed to teach me a few things, like how to create an android app.

Homework is frequent, one every week, but because they are so frequent the work is easy. If you know unit testing, android programming, UML, or whatever, you will get the homework done in a few hours. No massive time sink projects like most every other class.

The TAs are responsive, Piazza is helpful, the projects are easy yet interesting - A must-take class for everyone.

Cons:

I am surprised anyone could dislike this class. All the complaints I am seeing on omscentral are minor.

Grading is slow but that’s Every class.

Some of the assignments are open-ended but that’s exactly how it will be in the real world. The github assignment was very nit-picky (I lost points for not capitalizing ‘Assignment’), but I appreciate a challenge. People seemed upset that certain scenarios were not covered and the TA always answered the same way, basically, ‘its up to you’, which I thought was great. You get to actually learn, not just codemonkey paper to code.

A significant number of people whined how assignments were due friday, not the usual sunday/monday, but frankly I don’t get that. It forces you to start work immediately, and that’s a good thing. What does it matter what day you run into problems on? The TAs are less likely to answer questions on a saturday/sunday so I was very happy they were always available on a thursday night.

Some were upset by the class being too easy - to those people I say: Go take Computer Vision, or Compilers, then come back and complain about things being easy.

This class is the perfect example of how to teach. I loved it because the professor is always there with you and the TAs are helpful. There are 7 assignments and 2 projects. One group project and one individual project. My experience was good overall. I learned and refreshed my knowledge. I took this course in the fall of 2018.

Took this course in the first term. Prof. Alex was quite engaging and did a fantastic job of the course. This is a very good course to get in touch with several aspects of software engineering for the students that have been out of touch with the latest and greatest development practices. (Read Project Managers or Engineering Managers getting into the program).

Overall this course was well run. Will was a very active Teaching Assistant, who was quite engaged and made a difference to the students.

This is a good first class for the OMSCS program. No tests, 7 assignments of low difficulty, one of which is a group project that spans across multiple weeks with deliverables at weekly intervals. The amount of time necessary for this class depends on your previous experience with the technology stack. The assignments are completed in Java, the projects are based on creating Android Apps, and you use Git. I had never used Java, built an Android App, or used Git so it took me considerably more time than most because I had to learn those concepts as a went, but I would still say it’s low difficulty. Don’t waste time with the group projects trying to delegate work; figure out who will work on what and start.

Really easy class, good for pairing with a second class. No tests, weekly projects were easy to quickly knockout.

I enjoyed this class, though it was well put together. Dr. Orso was great. I think if you are working as a Sr. Software Developer for years, this will not have a lot of new information for you in terms of things you can use at work. But it is still interesting to see how/why things are they way they are.

For anyone that has any software development experience they may find this class useless. Would recommend as a first class to get an understanding of all of the software that will be used for the program (piazza, canvas, etc.) This is a very good course to pair with something else. I would highly recommend those students that are coming from a non-programming background start with this course as it will help accelerate their learning and help them catch up to those with experience. The individual project was very easy. The group project was only “hard” because it required collaboration with other people where the schedule’s may not have lined up exactly.

Overall I liked this course. I am PMP certified and work in an Agile DevOps team, so not a lot of the video content was new but it was a good refresher. I really enjoyed the Android project and learned a lot. I am tempted to take some of the other Software courses now.

Easy foundation course for computing systems

The course is a typical software engineering course walking through most aspects of software engineering. Professor Orso is a nice guy and great to interact with during office hours. I finished with a really close borderline grade and was upset by the support from the head TA. The individual is frustrating to work with and I feel my grades suffered from the interactions– penalties threatened for requesting clarification on grades. If the TA moves on I highly recommend it and if you are in the II specialization it is all but required. Let us hope the individual finally finds a job and moves on.

If you have previous education in CS this is a very easy course. That was my case, so this course was more like an update than learning new things. There is a few projects to do so the workload is a little on the heavy side but not complicated at all.

Easy class, but took in summer. Course had multiple assignments in a week few times. Would be a good Spring or Fall course. Students might not like, the assignments rolled out Saturday morning ET and were due next Friday midnight. Worked for me, spent the weekend in bulk of work and if necessary corrections during the week.

Prof Orso is great, however he was travelling most of the term and couldn’t make it to few office hours. TAs Erin and Will were great. I wish they used more interactive way for office hours than YouTube Live.

A very straight-forward class which you can easily ace if you have some programming experience. The course uses java and android as programming languages (all but one of the individual assignments were in java, group project was andriod as was one of the assignment). I had java experience but no andriod but this did not prove to to be a challenge. Grading was slow but lenient. Important to read the assignment instructions carefully since the grading is tied to completing each ask. Office hours were good and a the professor and head TA’s were open to provide hints/tips, so make sure that you go over the office hours video offline.

Over all a good but easy class.

Good course, but be wary of the group project. Your workload/love for this course will heavily depend on the group you are assigned. In my semester these were randomly assigned based on a quick survey at the beginning of the class

This is a good course.

This course was very simple and basic. Many of the concepts were things you would use in a software engineer role. I think it would be a useful course for students without any professional experience in CS.

Good first class!

I am fairly new software developer so I got a lot out of this course (Java, git, android). Their grading was too slow but they were pretty generous so you wil get A easily as long as you submit the assignments on time.

Assignments are due every Friday midnight and released Saturday morning. It helped me not to procrastinate so I was okay with it. But when you work in group projects, you might not want to schedule anything Thursday or Friday evening lol.

There is one individual and one group project that are in android. For individual assignment, even without android experience, it was very easy. Group project, on the other hand, was so much harder so it was very challenging to complete it. I really wish that they provided more resources on Android. Udacity lectures on Android was not enough for our group project. But i dont think they will so be prepared to study Android on your own for this course!

I enjoyed this course. Dr. Orso is actively and enthusiastically involved in it, and the lectures and assignments are well produced, fun, and educational. If you’re a long-time professional developer, there’s not a lot of new stuff to cover, but this is a great summer class for fulfilling a Computing Systems core course requirement. I did learn a lot about Android development, and I enjoyed learning about the TSL generator for category partition testing. I didn’t enjoy the group project though. The formal docs were mostly a waste of time, and I did much more than my share of the project coding. So, the group project skewed my overall workload (hrs/week) way up.

You cannot work ahead was an issue. The group project is very important and requires finding a good group early. We had some drop from our group of four which hurt. Probably a good first course if you have a software development background otherwise you will be playing catchup. Most of the coding was in regular Java and Java on Android which was fun.

Overall a very straight-forward class but there are almost no rubrics to be graded against unless they are baked into the assignment themselves (such as builds passing). Group project made me realize I never want to do a group project in another OMSCS class ever again. Minimal buy-in from others and like others have said, if you have a background in development it introduces nothing new. Usual case of TAs not always being helpful which is probably due to the number of TAs. Professor was very enthusiastic about the material but the fact that the grades are slow to come out and also drive later assignments really killed my enjoyment of the class.

Good course, but not all it was cracked up to be based on the reviews I read.

Be sure to pay attention to every word of the instructions because they are quite nit-picky about grading sometimes.

Overall, I enjoyed this class as I learned/refreshed a lot of software engineering practices. A good first class to get started in the program.

I have been a developer for 20+ years. This is my 9th class in the program. The material in this class is incredibly important for any software engineer to know. The lectures were very well done and the assignments/projects used the material from the lectures.

Unfortunately, this semester (summer 2018) was run very poorly. My impression from Piazza was that the TA dislikes working with people. This is common with engineers, but is not a good trait for a TA.The assignment documentation lacks detail, and the TA’s attitude was, “take your best guess.” This is not helpful in a class that is supposed to be teaching good development habits. A developer should never “take a guess” on a specification.

The lack of details in the assignments and individual project make work that should have been fun (but easy) significantly more difficult than it had to be for no return in learning.

On the other hand, the group project was very well designed. It was great idea to allow us to grade our teamates. This forced everyone to contribute and get along. I really enjoyed the team project.

This class is effectively mandatory, so take it, get it out of the way, and don’t look back. Some useful concepts are taught in the testing area. In practical terms, that’s the most beneficial part of the class. As a veteran programmer, I found the scope of the class project appropriate. But God help you if you get on a bad team. I put down an average of 12 hours/week for the course, but that includes 2 weeks of 40+ hours of class project work making up for the lack of participation of 2 people on a 4-person team. My other teammate was incredible, thankfully, and we pulled it out. Overall I would avoid this course if possible as there’s not much to learn here if you have an undergrad in IT or engineering. Annoyingly, the instructor is very old-school when it comes to assignment release dates and downright fascist about requiring assignments to be turned in Saturday morning instead of Sunday evening/Monday morning like any rational person would.

Easy course overall, but a lot can depend on the random assignment of classmates for the group project developing an Android app. Avoid if you’re not confident you could handle a lot of the work required in the event that you end up with a mediocre group.

This was my second course in the program. I have worked as a software developer for a few years but had not been involved in building complete applications so I thought I could learn a few things. I certainly learned a few things here and there but a lot of it seemed like common sense to me due to my work experience. Overall the class was very easy. It would take about 5 hours a week at most to take care of everything due for that week. The only exception to this was the group project. Despite the compressed schedule during the summer there were times I felt like I wasn’t taking any class at all. The class covers the software development lifecycle and testing methodologies but never really goes in depth into any of the topics. As a result you will walk away with a basic familiarity of the material but nothing more. If you have absolutely no development experience this can be useful but I don’t see much value in this course for anyone who has even a little bit of experience. The grading was very slow and as I write this having turned in my last project there is still about 50% of the work left to grade. The instructor is very enthusiastic and explains the material well. I enjoyed the lectures and the projects. I just wish we could have covered the material in more depth. In conclusion I would recommend this class to anyone coming from a non CS background and has not worked in industry. For the others, there is not much to learn here and your time and effort would be better spent taking one of the other classes.

I am slightly surprised that so many people rate this class highly. It’s kind of disappointing in many ways. The head TA on repeated occasions (I won’t out them by name here) is condescending and frankly never helpful. Their responses to Piazza posts (and given the fact that they answer the majority of posts) actively discouraged me from ever engaging with Piazza because I was concerned about asking a question that felt “stupid” or simple.

The projects are probably the worst part about the course. Many of them are simple, quick assignments that can be completed in a few hours if you have some Java knowledge. However, the layout and structuring around the projects (and the individual project itself) is a nuisance. The major issue is the assignment time frame. I took the course in the summer term, so the full semesters may be different. Each assignment was released on a Saturday and then due the following Saturday (7 days). No exceptions or previews. This means that if you have something come up for work, another class, etc. then good luck. You still have the same time frame. Not all classes in OMSCS give info ahead of time about projects. But when you expect students to turnaround an assignment in a single 7 day time window, there should be some level of foresight given upfront so they can plan for things. I had multiple occasions where I had to rush and turn in a subpar assignment because on Monday morning my work commitments would pile up for the week and I was left to choose between slacking off at my job or skimping on a course assignment.

The second major issue with the projects is that they are structured in an order which can actually hurt you later. For example, there’s a project around the 4th or 5th project that requires you to build a testing suite around a program that doesn’t actually exist, and you aren’t supposed to implement the program. However, in the individual project (which is 20% of the course grade), you are then expected to implement the program AND it must pass your test suite from weeks prior without making any changes to the test suite. This means that if you misunderstood a requirements, didn’t plan for something, etc. in the earlier project, then you’d potentially harm yourself in the later assignment (as you may have incorrect test cases based on assumptions at that point that you aren’t allowed to change). Why is this necessary? It just seems like poor planning for the course structure.

The final issue with the projects is that some of them simply feel watered down and unhelpful. The second part of the individual project involved the instructions saying that you had to change your program from part 1 because of “updated customer requirements”. In the real world, this happens. But in a graduate level course, what justifies this as an assignment? It is hard to see how that part of the project is anything more than busy work.

Grading is slow and obtuse. They have a ton of students and about 6-7 TAs. The rough math comes out to 40-50 students per TA, which is actually about average for many courses. I am a TA for a course that has an assignment of about 45 students per TA. In SDP, they don’t release grades for weeks. 8 weeks into the course, they have only finished grades for the first 4 (out of about 10-12) assignments. There is only a week left in the official course. So, they are considerably slower at grading than other courses in OMSCS, and don’t expect feedback about earlier parts of large assignments before you complete the later parts. They also don’t give any details about the grading for projects, so don’t expect to understand where your grade comes from until the release grades, either.

Finally, the course material is fine. If you have any experience in software development, it is going to seem basic and boring. There’s nothing new or novel covered in the course. In fact, I honestly would put the course on par with an undergraduate SE course. It’s inoffensive, and there is a grade for completing the quizzes so they “force” you to go through the materials. There are no exams, however, so there’s no pressure to actually pay attention and absorb the material (unless you don’t have any SE background and the material is new to you). The projects only require a cursory knowledge of the week’s lessons.

This class is just about worthless if you’re already working as a software engineer. To make matters worse, you are very dependent on the group that you are placed in for the group project, which is by far the largest assignment. If you wind up carrying the burden of the development work, it can really suck. Also, the group project doesn’t carry nearly enough percentage of the grade to justify the time investment. I think the class could benefit from having a more general Java development project rather than something so Android-specific (with next to no Android background being given). The rest of the class is easy peasy. Pretty much a waste of time. From the get-go, the professor and TAs have an antagonistic relationship toward the class, not budging an inch on the Friday due dates. There is no purpose to the fact that they don’t release assignments more than a week ahead of time.

If you have any experience as a software developer this is a very easy course for you. Another way to look at it: you will not get a lot out of this course. Lectures are very light and superficial, there were 7 assignments doable in a rather short time, an individual project and a group project. There was no exam. Grading is generous (but not curved). The average median over all projects was 95.

The group project can be time consuming depending on your team. Teams get assigned based on availability and experience (you fill out a google form for that) - you can’t choose your team members.

Overall: most of the time I felt like I was wasting my time. Exception: the group project where I was working day and night.

This course is of medium difficulty. For someone having java/web development experience, this course would not hold any value. I am a mainframe programmer from a decade and hardly had any experience with java coding experience, so i learned few basics about java coding and also android development. The lectures were good, but did not taught me anything new as i am already used to work in agile environment.

Grades are always late and no one knows for what marks will be deducted. I lost few marks in some assignments because of fat-fingering few spellings.

If anything, take this class if you like your lectures spoken with a cool Euro accent.

I think the grading was generous. As long as you read the assignments very carefully, you should get > 95% on all assignments. I read on the forum, though, that many complained about getting major points off, but that’s their own fault for not following directions. What else… forums are very active. If you ask a question, you’ll get many answers within an hour or so.

The Lead TA’s are awesome! They provided really good feedback in Piazza, and at least one TA used to answer questions in the Slack channel.

As much as I loved this course, the only I didn’t like were the Friday deadlines. I was calling in sick every Friday to finish my assignments, until my boss pulled me into a breakout room to have a 1-on-1. He thought I wanted 3-day weekends every week. lol.

In summary, take the course if you want to learn Android, or if you want to learn techniques on how to write quality code.

This course was a lot of fun. I could see where anyone with significant development experience might find it boring but I myself enjoyed it and encourage any new OMSCS student to take it. Dr. Orso was active on Piazza and held regular offices hours. Lecture material was well put together and entertaining. The TAs were very active on Piazza. There was only one group project that lasted about 3 full weeks. For individual homework, I advise that you do pay close attention to details. The material isn’t very difficult but you will lose a large number of points for small mistakes that could have easily been avoided by reading the assignment more closely.

Simply the waste of time. Avoid it if you can. I mainly took it to pair with a hard class, but apparently there are other better-use-of-time classes for that. Worst part is the head TA. She is a I-know-it-all and not very helpful. TAs enforce an environment on Piazza where students can’t help others. I felt bad for some students who genuinely put in all the effort but got stuck in some trivial parts of assignments. But TAs would never give a simple straight answer. It would rather be circular and useless.

Oh, and grading is super slow and frustrating. I didn’t know more than 55% of my grade till last week of semester.

I am glad that I’ve taken this as the starting course of OMSCS. Overall, it is a very gentle and basic class to learn Java and software design & testing

Video & Office Hour: it is short and fun to watch. Prof.Alex is very engaged and TAs are involved with Office Hour and have been on the Piazza all the time. Thumb up to Head of TA and Erin, who are most responsible TAs I’ve encountered so far in my education.

Assignment & Project: 7 Assignment 1 Group Project and 1 Individual Project First 3 Assignments teach you to write simple Java program in IDE. Group Project is to step-by-step design and to build an Android App. I think it is a good intro for software development process, including documentation, UML, test plan and even some database skill to prepare the overall structure of the app. But don’t worry about you have to do it all by yourself. Highly suggest you get a better computer in order to run the android studio smoothly. It saves your testing time for quite a bit. I think the Individual project is a little bit easy and less practical in term software design. Though it covered the course content of black-box testing and refactoring, we didn’t get to practice that on a complete software program.(It is a small command line utility)

If you think you don’t have any CS background, you could take this course as the only one and first course. If you have any background in Java or familiar with another programming language, I would suggest you to take this class with another medium or easy class in your first semester or take it in the summer.

Enjoy this class with good discussion and helps from classmates!

This is a good introductory course. You will get familiar with Java and create an Android application from designing it to actually coding it and testing it. It is important to have a good group and they try to pair the groups so that each team has someone with prior development experience.

Background

I have Java (10+ years) and Android experience( 2+ years), so the review might be a little biased.

Course Content

Videos were a bit too long and if you have been developing software development in any capacity following a lifecycle, should be really simple.

Udacity Quizzes

The udacity quizzes can be taken as many times as required with no penalty, but make sure your last submission is correct as they are counted against the grade.

Assignments

The assignments attempt to build on top of each other with the second half being a group project. Be brutally honest about your skillsets to be matched correctly. There were few teams who had lot of trouble leading to disparaging discussions in Piazza.

If you have Junits and/or Java development experience, the assignments itself should be a breeze. The only problem would be a black-box testing assignment with no clue about what bugs you are looking for. I would recommend living with whatever is possible as at the end of the day, it accounts only for a small part of your final grade.

In the group project, attempt to identify an integration lead, ideally with Android experience. It would make all team mates lives simpler with each building one or more components and the lead integrating them together.

I was the lead and all my other team mates either had paired this with other courses or were either getting a baby or moving, so getting the right team and responsibilities is crucial. There are 3 deliverables as a group and getting the dynamics is important to get them delivered.

Exams/Tests

There are no exams and all grading is done via Assignments

Office hours

This is the only 1 course out of the 3 that i have taken where the professor actually does a live office hours.

Parting words

If you have Java experience, this is a simple no-brainer class which can be clubbed together with another course. If you have no Java experience or haven’t worked in a group, i would tread a bit light and look for an alternative if possible. The learnings are not that really extraordinary nor the effort worth the merit.

After having many years of industry experience, I felt this course is very basic and assignments/projects were okay not great. Well, If you are just into software industry and trying to learn basics, this may be a good course.

Course lectures provide good examples and walkthroughs. There’s a historical context for each lesson which I liked.

The Android lessons need more work. The group project involves making a Wheel of Fortune app. The implementation is somewhat important, but the bulk of the grade comes from the design documents and project plan that your group creates. I didn’t know much in terms of Android development so going from the first individual Android assignment to the group project was a bit of a stretch. Someone else in my group was knowledgeable about Android which helped. You don’t get to choose your group, but you can assign preferences for meetings times. Hint: choose to meet early in the week before project deadlines.

Individual project is implementing a command line utility. The focus is on testing and refactoring. It’s straightforward, and while the black-box testing assignment doesn’t provide much in the way of learning, I did find the overall project helpful for thinking about test cases and inputs.

Good course to kick off the OMSCS program and pair with a harder course.

Not too hard of a course if you have Java experience. The group project is in the middle, making it an ideal course to pair with another course that has a heavy work load toward the end of the semester. The topics are well covered and easy to grasp, but there are a couple projects that are grind it out, type that make the class less enjoyable.

This was my first class in the program and I thought it was quite well done. The class eases students into development the first few weeks by giving several introductory individual assignments at the beginning including a review of github, Java and Java testing. These will be a breeze for anyone who works as a software engineer already, but gives a nice review and catch up time to those who aren’t. Thus, if you aren’t a software developer you have a few weeks to ramp up. The group project was perhaps the most time consuming part of the class and also my lowest grade in the class. Overall, the group assignment was not so difficult technically, but the struggle of my group was procrastination by 2 members such that I didn’t have time to review and fix what they worked on. The white box/black box testing assignments near the end of the term were interesting, though highly academic and theoretical. Overall, this is a great first class for the OMSCS program, especially if you are already a software developer. The class will also keep you on track with set deadlines and assignments coming out at manageable intervals.

This course feels like the easiest I’ve taken in the program, but this may be due to the fact that it is very well organized, clearly structured and not ambiguous. There are individual assignments with enough time to complete and a group project that is a small Android app. The lectures are fabulous in their flow and design and quite interesting, even if a lot of it might be familiar to someone working in software development. It was still helpful to have the material laid out in such a fun way. Getting an introduction to Android was also great.

Considering the ambiguous nature of the rest of the classes I’ve taken, SDP is now engraved in my mind as a sweet memory. I wish more classes were like this - I feel that many other classes try to cram an inappropriate amount of material, which causes them to be kind of all over the place.

I’ve been a developer/coder for 18yrs; so the concepts that this course taught were nothing new to me. I didn’t learn anything new; however I would recommend this course as someone’s first OMSCS course. I’ve read quite a few bad reviews; and didn’t experience anything like what was mentioned. The projects in the course were fairly easy and didn’t take me much time; but again, I’ve been developing for while.

I had a horrible time with this class. Everything was subjective to the TA’s and the group project was unbearable (I had a really bad group). If you have any real world experience, this class is a waste of your time. I did not learn ANYTHING new from this class. Everything is “Perfect World Scenario” with no explanation of how it really works in implementation. I understand that this is a class teaching about the theory of software development, but does not give a real outlook of how it works in industry.

This course is a great intro to the OMSCS in general. It includes group projects to get you used to coding with a remote team, but at the same time will teach you the basics like using git. For most people who work in SW Development, the content won’t be anything new, but the chance to create something in a group is always beneficial.

I enjoyed a lot of the material and thought it was a good course for people who have not been working in a software company that primarily uses object oriented programing. I have mainly been in silicon and embedded systems development (C heavy) so found the material quite good as a survey of understanding potential processes outside of that environment. The weekly assignments differed greatly in difficultly and completeness of instructions, the TAs would help clarify - but if they thought it was clear enough they would stop.

I really disliked the Friday due date of assignments - the only way to make this work with the curriculum is to stay one week ahead of the published schedule otherwise the weekend is wasted as you don’t have the background needed to make progress. This made the course interfere with work much more than it should have, particularly for the bigger assignments.

Grading was always really late - especially annoying for assignments that built on one another (and it turned out the multi-phase assignments only got one grade at the end.)

This is a very good course for JAVA or Android starter. This is a good course for the introduction of software engineering. It may not be useful for those who have much experience from industry.

While this class is very broad in covering content and the lecture videos were excellent, the assignments were almost always monotonous and there were huge logistics issues. The assignments were almost always returned about a month later so it took forever to know how well you were doing, the group project (at least in my case) had 4 students in 3 different continents and it was hard collaborating discussions as the meetings for me were always either 1 am or 9 am (not sure if this was just bad luck for me.. or?). The projects themselves were quite interesting but I thought some topics were rushed too much while others had too much time spent on focusing a minute detail that doesn’t really matter in the software engineering world.

Overall, the course content was pretty decent and a great learning experience, but the logistics of the class itself has turned me away from the class.

Pretty easy class, and you won’t learn much if you’ve done any software development in your career. I was just starting my career when I took this so learning to use git was useful. There’s some exposure to developing a basic android app and working with a team which is useful. This class is definitely more valuable at the beginning of the program as opposed to later, and pairs well with anything.

I think if you already have considerable experience in software developing, this class would both be easy and useless for you. The class covers a wide range of content but doesn’t go enough in depth with any of them. The weekly programming assignments also seem to lag the readings a bit (you’ll be doing an assignment in Lesson 6 when the reading schedule indicates Lesson 7 or 8).

I don’t even consider myself an experienced software developer and there was only a few things I got out of this class that I felt I could apply in the real world. I didn’t get enough hands on experience with Android development to be confident enough to enter that field. I got SOME useful experience with black and white box testing which I liked. Other than that I got some Java experience and that’s about it. There’s an opportunity to get a little bit of project management experience if you volunteer to be the leader for the group project but the curriculum doesn’t go into software project management. I do wish the group project was shaped to focus on a particular software development strategy (e.g Agile, Waterfall, etc). I also wish there was a project on refactoring as the lesson material covered that but the projects didn’t.

Useless class.

As an experienced developer, I have a lot of problems with this course and completely regret taking it. The professor read a bunch of papers in the early 90s and decided to make a class based on his naive understanding of software development. It is easy to get an A if you follow instructions closely and prioritize what the professor and TAs think is important.

Also, very much a TAs vs. students environment; I never felt like they were trying to teach us, but instead using us to make their lives easier (even though they still took 8+ weeks to grade a single homework on some occasions). I think this is because there wasn’t really anything to teach.

Waste of my time and waste of money.

I would say this class was really easy in the sense that it wasn’t super stressful and the projects didn’t feel like ‘homework’. If you’re looking to take multiple classes at once I’d consider doing so alongside SDP.

Good intro course to software development, Android and JUnit testing. The group project and Individual project were interesting, but focus on testing is a lot in individual project. I learnt Java and Android development while doing the course so anyone with good software background will find the course easy. The bad part is all the submissions have Friday deadline, which makes it a very stressful week especially if you are working.

DISCLAIMERS: This was my first course in the program, so I spent a fair amount of time early in the semester learning basic OMSCS infrastructure (Udacity, Piazza, T-Square, slack). Related, although I have experience as a software engineer, my current job is entirely different. So I also spent a good chuck of time creating a workable setup on my machine (Cygwin, .bashrc aliases, git). Finally, although Java is clearly stated as a prerequisite, my closest experience is C++ from 15 years ago. So coming up to speed there was nontrivial.

PROS: Professor Orso is a ton of fun! The lectures are great and the office hours are helpful. I enjoyed the material and appreciated the weekly assignment cadence. This course has been refined over many iterations, and the instructors are very clear that the decision to make each assignment due on Saturday morning is a deliberate one. Initially I was unhappy about this, but came to rather enjoy it by using some weekend time to get ahead on the homework rather than scrambling to meet the deadline. We were exposed to several technologies and tools (git, IntelliJ IDEA, Android Studio, Java, JUnit, markdown, XML). The Android Studio group project was a lot of fun. Groups were assigned based on mutually available meeting times and complementary Java experience, which worked out great!

CONS: Assignment grades were consistently very late. I literally had no idea how I was doing in the course for the first half of the semester. (As a new student, this was particularly unsettling!) The instructors take grading very seriously, and go to lengths to ensure fairness by making sure grade distribution from TA to TA isn’t skewed, releasing all grades simultaneously, and so on. I do prefer a fair grade over a fast grade, so I appreciated this. However, I think it’s also reasonable to expect timely qualitative feedback, perhaps with a delayed quantitative grade. (Otherwise, there’s no difference between OMSCS and watching Lynda videos!) I felt the lack of timely feedback hampered my learning and caused unnecessary anxiety.

Overall, this course was a very good intro to the OMSCS program for me, and provided an overview of software development techniques I had always wanted to learn. The Udacity lectures were informative with easy-to-grasp concepts, and Professor Orso has inspiring enthusiasm for the subject matter. This being my first course I can’t compare to other GT classes, but this is easily the best online course I have ever taken. I appreciated the weekly YouTube office hours and was not required to post a mindless forum thread on a weekly basis, in contrast to my undergrad experience. The weekly workload is entirely doable if you read the instructions CAREFULLY and IGNORE your classmates’ forum posts until you’ve absolutely hit a wall and need an answer to something in particular. Using this strategy, even while working 50 hour weeks I devoted about 4 days out of the week to schoolwork (this 1 class) and managed to get no less than a 94% on each assignment, I consider myself a software developer newbie with average intelligence. My favorite part of the course was the group project which we split up equally on documentation and coding, and I could not have asked for a better team. Having said all that, the TAs do take their sweet time on grading assignments, apparently especially if you choose to contest a grade (I did not), and I rarely saw any interaction by other TAs on the forum besides the two heads (perhaps they were grading?). There are some concepts that I would have liked to go deeper on, such as Agile, and the lectures could be updated with lessons on the currently used software. These did not manage to spoil my enjoyment of the course.

First, the good: Professor Orso is a good lecturer and is passionate about the material. There are some interesting individual and group projects. I particularly liked the ones on Android and White-Box Testing. I plan on using what we learned about Extended TSL for automating test cases at work.

The bad:

• Holy hell, the TAs are awful. I’m more than half-way done with my OMSCS degree, so this isn’t my first rodeo - this has been without a doubt my worst course experience. The co-head TAs (Will and Erin) are defensive, easy to anger, slow to answer threads, and almost purposefully ambiguous in their replies to simple yes or no questions (e. g. “is X a requirement?” or “Should the behavior be X or Y?”). I’m a pretty agreeable person, but I feel like I need to get my blood pressure examined after each interaction with them on Piazza.

• The assignment docs are poorly proof-read, contain errors, and are often ambiguous.

• There is an assignment due every Friday night (or early Saturday depending on your time-zone). Assignments are released the previous Saturday morning. This wouldn’t be so bad if the TAs were responsive - but posts routinely take 2-3 days to get a response. Usually the responses are ambiguous, defensive, and over-all unhelpful. All in all, this makes for a stressful weekly experience. SUGGESTION TO THE PROFESSOR: Please consider releasing assignments 1-2 days early (Thursday instead of Saturday). Or work with your TAs to get better response times. Or have the TAs do a better job at proof-reading the assignments beforehand.

• Feedback is non-existent. It’s November 10th, and we’re still waiting for grades on assignments that were submitted back in September. The feedback we have gotten has been one or two poorly worded sentences. A silver lining is that the TAs grade easy; but I’m here to learn and feedback is crucial to that process. Other OMSCS classes do a really good job at feedback, so it’s definitely possible with a class this size.

Like some others have posted, I am not sure how is it that there are students giving 5 stars for this course. I do not necessarily blame the professor, rather, the TA’s. These are the worst TA’s I have ever had. At this moment, we have been waiting for answers for questions for the assignment due this week (November 8, 2017), and it is 3 days and we haven’t received answers. But guess what! Yes, when it comes to grade the assignments do not expect the best results, these TA’s are like in the Olympus, untouchable. They use this autograde system that will never grade as a human does. Even if you are not very good developing, their comments or feedback will push down, making you feel like you are not worthy of becoming a developer, or something else, because we have to be honest, this master program isn’t to make ‘software developers’, it is for anybody in the area of computer science: IT engineers, developers, architects, etc. The name of this course sounds interesting, but the content to me is awful. I don’t know the reason we have to be doing like more than 50% in software testing if there is already a course called ‘Software Analysis and Testing’.

By the way, get ready to be part of an experiment, when it comes to use this tool called ‘TSLGenerator’. There is no valuable information on the internet for this, nor videos, etc. Nothing! The little you can learn you get from the Udacity lectures. So, the only reason I am taking it is because it is one of the options as requirements. The other course is ‘Computability, Algorithms, and Complexity’, thus, either you take SDP or you take CAC.

The schedule for assignments due? The worst! They are due every Friday night; Saturday morning for some people. I wonder why they do that, when other courses assignments are due on Sundays. It looks like the people leading this course do not have a sense of humanity. They do not care if you have a family or if you are in another course: assignments are due every week on Friday!

The instructors are not available to answer questions. They claim that they cannot guarantee a response in 24-48 hours. The course is more about following the process. There are assignments every week, which kind of make it hard. For me, with a baby arriving in September and full time job, the weekly assignments made my life a hell. I was constantly chasing a target. The assignments are very ambiguous and requires the help of other students to understand what is asked. Assignments submitted are not graded even after 2 months of submission. In all, I would say avoid this subject if possible. There are many other good subjects and good TAs around there.

Very Good software development foundation course, taught passionately by Dr. Orso and TA Team. Office Hours were conducted diligently and all clarification questions were addressed nicely. Very good Piazza Participation. Only downside was having team project and individual assignments going on in parallel during the summer time, making it very tight. The fall and spring semesters may not encounter this issue.

I would recommend this course if you have no prior software engineering background, though I would skip it if you have had an undergrad SE class or SE work experience. There is no major challenge to the projects themselves, as they aren’t designed to test you on your ability to solve problems, just how well you follow process and complete documentation (which isn’t a complaint, that’s the point of the class!). Unfortunately, there wasn’t much engagement in the process beyond wrote tasks and standard documentation. Since the projects are fairly trivial, it seems silly to spend so much time on design and discussion, so hopefully in the future they use projects that are a bit more complex, or maybe having to deal with changing requirements or incomplete requirements. That being said, if you don’t have any experience in software development or process, this is probably a good introduction to it.

If I were to give advice to those taking the class, I would say two things:

1. Be careful with your time, the Summer section was quite fast-paced, and it is easy to fall behind. The instructors insist on making things due on Friday, and make things very awkward for those who work. You can get some of the projects done on the weekend they open, but Piazza comments and project errata will appear during the week, so you still have to work around your weekday schedule unfortunately!
2. Check your work over until you feel paranoid about it. The instructors are not very compassionate nor understanding when it comes to simple mistakes. I personally was only affected by this once at the very beginning of the course, but two of my teammates lost a full letter grade due to this. If something isn’t compatible with the auto-grader, or there was a simple typo in a commit hash, function name, etc., then expect to receive zero points for that portion of the assignment, with no real wiggle room!

With a good group around me, I found the Android project really edifying about Android, but not really about software development as a process. You write a lot of docs, code the project, then backfill your docs with what really happened. You create one really useful diagram that makes you think, and a ton of expository writing that just fills pages. So, a lot like any highly regulated domain. This presumably forms the core of the class.

However, in summer, you get the thrill of concurrent group and individual assignments. The individual assignments contain a lot of “aha!” moments that can take hours or days to find. But you don’t have hours or days - you spent those on Android. I bet these individual assignments carry meaning in a longer term. In summer, they stand in the way. The course lectures don’t have the information or the presentation quality to pull off “aha” assignments. Most of what you need, you find googling. And you don’t share what you find because you never know how close you walk the line of distributing unfair information.

I would have felt much happier ignoring the lectures and spending that time on the individual assignments. Really, they do not help.

Last point (completely serious): The instructors do not believe in the western tradition of starting things on Monday. They live in an alternate calendar. Get ready to fight it out with your bosses and spouses. This course has no respect for your school/work/life balance, and throws many obstacles in your way. Much harder courses strike the balance, why can’t this?

This a good introductory course for new students, people without programming backgrounds, or those that want to dip their toes in.

Lectures and assignments are done very well and although there are some hiccups they are in the realm of what I would expect for a large class (200-400 students) and one taught online. Grading is very fair although one of my complaints in a lot of these lower level classes is that roughly 50% of the class gets 100% on assignments and then there is a steep drop off. You either aced the testing criteria the TA / Professor had in place or you lose 10, 15, 30%. I would rather see an actual bell curve where very few students get 100% even if the majority get 90+.

Besides the group project, all of the programming required is on par with sophomore level programming classes especially if you have any Java experience. For the other assignments such as defining test cases, diagrams, etc. I only found about 20-30% of it actually value added but I appreciate being exposed to these various tools even if at the end of the day I didn’t find many of them useful in the real world.

For the group project, as many others have mentioned, it is very dependent on your teammates. That being said, you can do yourself a big favor by assigning tasks based on individual skills, don’t try to break it up “evenly” or “fairly”. If one member of your team writes android applications professionally there is nothing wrong with having that person write the entire app themselves. Another person do all of the diagrams, and another all of the writeup. Run your team like you would an interdisciplinary team at work.

I gave 3 stars as I personally didn’t learn much in this class, if you come in to OMSCS with a lot of coding experience its ok to skip this one and take something more challenging or interesting.

If you’re a programmer and you want to brush up on the best practices in development, this course is for you. I had long forgotten about best practices and processes. A good course to be reminded of them. The TAs and Prof are very active on Piazza. I took it in the summer so there was one assignment every week, which can be a little frustrating. The team projects needs collaboration. I had an awesome team. The tip, respect other people’s opinion, its ok to give in sometimes and keep it simple… and do not take anything personal.. its all about the grade. There is one individual project.. follow up on piazza to get through it.. I got it working due to posts on piazza..

Good luck.

Basically an “intro to industry” course. This course is a broad survey of topics relating to how the real world does software development. Includes a group and individual project. The group project can be either very easy or very hard depending on your group - in my case, it wound up being incredibly time consuming (>40 hours one week because I had two absentee group members). I wouldn’t recommend taking this course in the summer for just that reason - I don’t think they scale the project back for the accelerated schedule, and one bad week of coordination can tank your schedule.

The lectures are informative and well-done. The professor and TAs are very involved with the class, and I’d take another course from Orso in a heartbeat.

If it’s been a while since you’ve worked as a software engineer in a modern environment, this is a great course. If you’re like me, and have been one for more than half a decade, it’s probably less valuable.

The lecture videos were very well presented and were professionally produced. The professor and TAs were active online and responsive to student questions. These aspects should serve as the gold standard for the class materials and instructor involvement in all OMSCS class offerings.

Much of the class will be a review if you have worked in the software development industry, but it never hurts to review and there’s always a thing or two left to learn. The projects were sufficiently entertaining and educational. Some prior OO and GUI programming experience will go a long way to eliminating any frustrations with this class.

The group project experience depends largely on the project partners who are assigned to you. I worked with excellent individuals, and the 4 of us just automagically dove into our imagined roles and pounded out a project with a good score. Though there is a mechanism to adjust scoring should there be inequities in contribution from the other group partners (or so I’ve heard).

Based on conversations with others, there were additional projects that are now in place where they weren’t present previously in prior summer semesters. The final projects (both group & individual) were running somewhat in parallel and can make things busy.

TLDR: Great course that teaches the fundamentals of the software development process, however, it uses some outdated practices in what is taught. Professor highly involved along with TAs. Highly recommended. Assignments released on Friday, due Friday (7 days). Makes a good, getting back into academics, course.

Prep: Have good familiarity java and android development; have the ability and time commitments to work with a team to get a group project done.

My expectations of this class were to refresh some of the basics that I already knew from coding in industry for 7+ years. The class met these expectations, but relied on some outdated information and documentation that is not actually used in the real world industry.

The course was a great overview of what it takes to develop software from the systems or business side of things. Not just the guts of programming. The course takes you through the steps from initial concept, requirements gathering, documenting designs for approvals, prototyping, reviewing designs again, implementation, testing, and final presentation\shipment for a software project.

The class leans more towards requirement gathering and documentation then programming, so be prepared for that.

The course had almost no flaws in it, besides the team picking process and getting the students to work together, but that is a separate issue. The TAs and professor were very helpful and willing to see the students learn the material.

As others have mentioned, while this is a decent course for those who are not good programmers, you still need to be able to program to take this course. This is a Computer Science Masters degree after all. This course also has little learning for industry experienced developers, but it worked as a decent transition back into academia after being out of it for a while.

This was a tough course for me having never been a software developer and knowing no java. Can be extremely time consuming. Luckily when you get teams to work with you are given teams with skills that compliment your own.

This class is very useful. It’s somewhat easy if you already have some software development experience. The teamwork was a challenge because some team members aren’t as dedicated plus dealing with schedules was a pain

The other reviews for this course are accurate. There is a lot of work (and some of it people think is monotonous), but the summer is shorter than the fall and spring semesters, so the amount of work per week is probably higher.

To prepare for the class, I recommend brushing up on Java and Android development. There are some good classes on Lynda for this purpose.

one of the more interesting classes, it required weekly assignments which were due saturday morning and released on saturday. the work was doable, but it was challenging.

Good class. They’ve changed the structure from previous summer’s. We had both an individual and a group project. I think the change really made the class a bit too hectic on weeks we had assignments and individual deliverables in the same week. Also, the TA’s weren’t able to keep up returning grades and feedback in time for projects that were dependent on prior assignments. I still really liked the class but expected with the class being offered every term since our program was started to be well oiled machine by this iteration.

This course can be easy if you already have experience as a software developer, but it can be challenging otherwise. Make sure you brush up on Java, Android, Git, and JUnit before taking this course. All of the coding is done in Java, using the IntelliJ and Android IDEs. You should probably take this course early in the program, as the language and tools used in this course will prepare you for other courses in the program. You will be building two Android applications in this course, one by yourself and one with a team. Hopefully you land in a team with at least two knowledgeable software developers, else you will be writing a lot of code on your own.

This is a great class to start the OMCS program off with! Gave me a good opportunity bang off some rust programming with Java and I got to learn some new stuff with android development. This class is project driven, which I really liked and I felt the projects were generally challenging/interesting.

Very good and passionate instructor. Made good use of Office Hours time. TA’s were helpful.

Make sure you inform instructor early on if one of your project team members is MIA.

Course was a good review of some of my undergrad work. Very good presentation of Agile and Scrum. The JAVA and Android was a nice change for development tasks.

Work with your group up front to find strengths and weaknesses. When it is your turn to be the task lead stay on top of it. Having team members in 5 time zones can be a challenge but it gives you a perspective of what it will be like for remote collaboration efforts.

Alex Orso is an excellent professor. This is a great beginner software course, and I really enjoyed the lectures. There was a final group project at the end in Android that was very time consuming, but other than that the assignments were straightforward for people who know Java.

This class stays true to its mission, which–as the name suggests–is to build up the ‘process’ parts of the skill set as opposed to the programming or theory skills you’ll get in other classes. This means that it may not be the best option for those that already have experience as a developer, but for those that don’t, you’ll get useful practice with Git, unit testing, UML, white-box testing, and black-box testing, among others. The assignments and individual project account for over 70% of the final grade, the group project accounts for another 25% (split 15% for the actual project and 10% for your teammates’ assessment of your collaboration), with a a few remaining free points from Udadcity tracking whether you watched the lectures and did the quizzes. As long as you follow instructions, the grading isn’t very strict. This class pairs well with other classes, though be aware that the workload during the month or so of the group project can be higher than for typical weeks. Professor Orso and the TAs were very involved and helpful. My main complaint was that the pace of grading was pretty slow.

Take this course if you don’t have software industry experience. Otherwise, you will learn so little. The course is very well organized and run. Staff are very interactive. Group projects could be a bit of a headache. Be prepared to do the most tedious/hated part of working in the software industry, documentation. Know your Java. And if you want to be the programmer in the group project, know Android dev.

This was one of the two courses I took my first semester in OMSCS. I come from a non-CS background and do not code for a living (Im actually in recruiting - ie.. sales). I have never written Java, never been exposed to unit testing, heard of UML but never messed with it. I do have a lot of procedural based coding experience, as well as have developed a CRM using MySql back end in VBA. I have done some PhP/MySql too, but not much.

I couldn’t recommend a course more highly, especially for a new student in the program. Dr. Orso was a joy in class, was involved weekly, always available, active on Piazza, and the weekly office hours were fantastic. More importantly for me, the projects made me think. I always (once released) said - oh, this wont take long. Once I got into it - I realized that the assignments were a little more involved and thought provoking than I first thought. The only assignment that I really wish were reviewed was the Category-Partition testing assignment. We had lectures on the subject, we used the application; however, I totally see the value in the tool, but not sure I really understand the best way to choose and assign categories and parameters.

As for the group Android project, I hit the mother-load with group members! All 4 of us put in a ton of effort on the project, and our grade reflected the work we did. We started early on the assignments, followed the instructions, completed the writing / required documentation, and by meeting multiple times during the week all assignments were submitted and complied with requirements.

If I had one recommendation, to me, the group project (15% weigh) should have been weighted higher. I certainly worked much more on that than I did on the individual project (which had 20% weight), it consumed more weeks in the course, and was a much more comprehensive effort than the individual project.

TA’s were Great and active daily. This class totally flipped how I approach software development!

The class is interesting but it all depends on your group. We had a terrible teammate for the first few weeks and that was a mess. But, the class ended up fine.

In three words: tedious and tiresome. The material is not difficult at all. I actually enjoyed the lecture videos. However, the mind numbing, useless and extremely tedious assignments and projects makes this course almost unbearable. If that wasn’t enough, your assignments are all due at 8 am on Saturday. Therefore, you can almost guarantee that this class will ruin every Friday the entire semester.

The assignments are intended to help you master a certain topic, however most of them are extremely unnecessary, vague and time consuming. I’ve never wondered in the desert before but I”m pretty sure this is what it feels like. Constantly wondering how you got into this situation, if you will ever see an end to the drought, wondering if you’re just walking in circles and elation when you’re finally done.

Do yourself a favor and avoid this class.

This class had very active TAs and instructor, which was great. It never goes super-deep into some of the topics, but is a good general course on software development. I had a pretty good group for the group project, with only one member not contributing much, so things went well and we received a good grade. I would recommend this class if you haven’t done much software development. I’ve done it off and on for 20 years and I found the topics to be pretty easy, but enjoyable.

Third class I’ve taken, and I absolutely do not understand the positive reviews for this class. If you have programmed in an OO language before, this class is a huge waste of your time. Several of the projects are tedious and are of limited value to programming In Real Life.

Example: In one project the assignment asks you to write 30 black-box test cases for “test-driven development” - when you have the source code (that you wrote) right in front of you. Actual worthwhile tests that you might write in industry are frowned upon. The standard “red-green-refactor” is barely mentioned in one lecture, and never really asked for in any assignment.

Grading is unbelievably slow. Assignment feedback (when you get it) is random and worthless. If you want an easy foundational class, go for it. If you want to learn something useful, avoid. This class made me seriously consider dropping out of the OMSCS program.

I should say something positive. If you’ve never written an Android app, you’ll get that opportunity. The group project is also somewhat enjoyable if you find yourself in a good group (which I did).

6 Individual Assignments, 3 Group Projects. Easy if you are a java programmer, but a nice easy intro to Android, which I haven’t kept up with. Test driven development, other development processes. Work is doable but constant, so take when you won’t miss weeks and have time to coordinate with a group.

This was my first OMS course. I enjoyed the video lectures and Professor Orso does a great job keeping you engaged in the subject matter. I really appreciate his breadth of knowledge and enthusiasm for the material. I was very impressed (and relieved) by the quality of the online delivery system and Piazza classroom forum.

What I liked most about CS 6300 is that it differed from your typical boring, textbook heavy software development course that beats SDLC to death. There is no textbook and no exams. Just quizzes and projects. I really enjoyed the projects because they were opportunities to apply course concepts. We learned Git, Android development, MD format, JUnit testing, and so much more! Many of the tools, such as IntelliJ and Android Studio (and even Git), I had never touched before. I learned so many useful tools and concepts that directly applied to my professional work.

Although the majority of reviewers rate this course as easy, I caution others not to under-estimate the effort required. I finished with an A but it did require an all-nighter once or twice to meet deadlines and weekly deliverables. Having a programming background definitely helps, especially Java. If you have zero programming background or you’re not strong in it then be prepared to suffer a little. The course will not be impossible but I found it challenging enough to meet deliverables because the week seemed to go by so fast between keeping up with lectures, quizzes, and the assignments themselves. I have over 10 years experience developing in C++, C#, Java, VB. NET, SQL, and some HTML and PHP and I felt I was barely prepared. There was still a lot of new learning I had to do and had to do it fast in order to complete assignments on time. I am thankful my group had others with programming experience. It is true that grading is slow but I feel the TAs were doing the best they could. I never felt the slow grading affected my progress or learning.

Overall a very well structured class. The professor and TAs are awesome in this class and very active so definitely use that resource. The course was mostly review for me, but it is definitely a good intro for people with a light programming background. Some Java experience is recommended.

SDP was my first class & I am not currently working in the software field. I have had programming experience 10 years back and more recent scripting work. I had to learn Java & Android for the course unlike some people who had both or at least Java background.

Every Friday there was an assignment due so it was a busy course. Some were easy, some not so much. I had a great group for the project so overall I loved the course. I felt like it was challenging enough for me but not too much, to be discouraging. I learned stuff and more importantly felt confident about getting back to school and taking harder courses.

There was a lot of gripe from people in the class about how easy the course was and I can see how it might have been. So if you are programming/scripting for work and are not looking for class fillers, please don’t bother taking this course. These reviews exist for a reason

Professor Orso made the lectures interesting, and we got to work with some cool languages. Grading was fair, and TAs were good at correcting mistakes. Using GIT to grade was a great idea, but I would recommend you check over the grades they give you. I had multiple instances where they used the wrong commit (mistakes happen), but again, they are quick to resolve these issues if you talk to them about it.

Course is entirely project based, with a group project, and a series of individual projects. Not being able to select your group is annoying, because the group project is pretty large and the time frame is really small. I ended up getting a team where two students did not pull their weight, and I had to do a large portion of the work, putting me in the position where I had to play catch up for that class and another class for the rest of the semester. Some of the projects can feel like busy work as well.

Knowing Java is ideal, but knowing Android will really help you on the group project.

The lectures are good. For a person coming with a significant background in programming, there may not be nothing new to learn in this course, except for Android programming, if one is not familiar already. Good engagement from professor.

Even as a person who did not come from a computer science background prior to entering OMSCS, I barely learned anything from this course. It should be said that Professor Orso is excellent, and the lectures themselves are reasonably good. However, the assignments and especially the time it took to have them returned left a huge amount to be desired.

Professor Orso is amazing - his lectures are fun, engaging, clear, concise. He’s also all over piazza, which is very encouraging for the students. As for the content - to be honest, I wish there was more content. And assignment material to practice it on. I committed less than 10 hours a week to this class, and covered the materials and tasks easily. I would’ve gladly committed another 5 to cover more content - maybe delve a bit deeper into design concepts, or perhaps an extra individual project with android.

This course is about the best practices in software development. The course is very well organized and provides a great coverage of the full-cycle of the software development from requirement collection to test-driven software development. There is no difficult concept to understand, the challenge of this course is really the follow the schedule and deliver assignment project on a weekly basis. I had no Java and Android development experience before, this course provided an excellent introduction to these two topics. The assignment for testing, i. e., white-box and black-box are really interesting. The instructors did a great job to design the individual assignment, which wraps up the important concepts and techniques of the entire course nicely. To me, the most challenging part of the course is the group project, this is partial due to the time commitment to work together with one free rider in the team. We struggled quite a bit, but in the end managed okay thanks to the generous grade given by the TAs. It would be easier for us to keep track of the course progress if the grades were released a bit earlier though.

This is an easy but good course. It teaches many concepts in software engineering that Non-CS students don’t learn in school. The concepts of software development tends to be overlooked. A good software is not just good coding. The workload is fine. There is deadline almost every week. It is a good course to refresh your java programming skill or even learn it if you don’t have much experience. The grading is lenient. I would actually recommend any Non-CS background student to take this course even though it appears to be easy, but many of the concepts in the course are basic but important to know as a formal CS student and can tell whether you are a CS student or CE/EE student if you don’t know them.

I definitely recommend this course as an intro to the OMSCS program. The professor is energetic and involved. The assignments were mostly practical and allow for proficiency with a bunch of development tools. Programming is in java, and db experience helped a lot with the group project. Speaking of the group project - I had a wonderful group and really enjoyed the group assignments, however some had a more negative experience. We were not allowed to select our groups so you have to make the best of what you are given.

The four weaknesses of the course were 1) VERY slow turnaround with grading. 2) The rubrics were not published and some of the grading seemed a bit nit-picky. There was one case in particular where instructions for a deliverable weren’t entirely clear, yet grading was strict on that section. 3) I was a bit disappointed with the final project since it wasn’t something one would ever encounter in the real-world, and it did not add much to what we had already learned in the class during the semester. 4) The Friday midnight deadlines were rough, especially since office hours weren’t until Weds evening. Would have preferred a Saturday midnight deadline so that some of the weekend could be used to finish things up after office hours.

Bottom line is that you will leave this course with a good understanding of the pros and cons of different development approaches. You will have completed some interesting white and black box testing assignments, and you will get a good start on Android development if you have never dabbled in that before. The professor and TAs are genuinely supportive. This is a relatively low-stress way to get back into an academic environment after being out of the classroom for many years.

Was a great way to be re-integrated into the CS curriculum. I’ve been out of the classroom setting for some time now and this class was simple enough, yet technical enough, to provide me with an opportunity to slowly get adjusted. The content was not too difficult however I do feel as if I learned.

Would have loved more resources to be identified to assist with self-study considering most of the class was just that.

This class can get a bit boring. However, you learn some useful development methodologies that are useful when you work on long projects or when you work on group projects. Also, you learn about test driven development which is a useful thing to know. Android development in this class is not that difficult. For the first android assignment, you practically follow a tutorial by the instructor with minor changes. For the group project, you will also use android but it is not that difficult as well. You will need to know how to integrate databases in your app as well as how to navigate through views in android. Other assignments are not bad and can be completed comfortably within 2 days. The instructor and TAs are involved and quite active on Piazza and generally do a good job in answering questions and clarifications.

This class is an excellent overview of the stated topic. I work at a large company in a division that develops software, and learned much about what certain processes are, why we do things a particular way, alternatives that could be explored and areas that could be improved. The actual coding of the class project was beyond my technical capabilities without a lot of additional work, but fortunately some of my teammates were well versed in programming Java and Android, and I was able to pick up more/most of the work on the requirements and documentation side to make up for it, which obviously helped and felt like a fair distribution. You will need some basic Java programming on your own as well, but if you have any kind of a programming background and take any beginners-level course, like the one offered by Udacity, you’ll be fine. The instructors is fantastic and funny, and the TA’s are very helpful and responsive. We went nuts with Piazza, which made it hard to keep up with, but that was our fault. Overall I highly recommend this class, even though it’s not a killer I think everyone who doesn’t have a highly detailed background in large-scale software development and management can benefit from it.

new to CS area from EE hardware field, gained knowledge, practices and confidence by doing those projects and assignments.

This was the first class I took through OMSCS. I enjoyed the class overall and learned a great deal too. Unlike some other OMSCS classes (that I’ve taken since taking one), I thought the lectures were done very well in this class. The professor and TAs were very helpful on piazza.

Easy class. Take it if you want a free A.

A good, interesting class with projects that do a good job of illustrating the concepts taught in the course.

I really enjoyed my time with this class. Professor Orso was a very strong teacher and his passion for the subject definitely bled through his lectures and office hours. I would advise that there is a TON of “ticky-tacky” grading in certain assignments especially where instructions are incredibly vague or opaque. I struggled not because the material was difficult but because assignments were never entirely clear or the lectures didn’t adequately prepare for assignments so you’re left researching stack overflow and other places for hours. The projects depending on Android development was a blast! It was cool to see Orso start us off on a mobile project and then implement some of the SDP concepts on the project. Also, you’re gonna need a good team for the project. By good I’m not talking about dev-savvy (though it helps). Good in this context means good communicators and overall team members. I had a fantastic team where we could depending on each other and split work appropriately. At the end of the day though, I have a tad bit of a bitter taste in my mouth because of a few assignments and some grading that I didn’t agree with 100% (and I’m not the complaining type for this stuff). If Orso and his crew were to re-work some assignments this would be a 5/5 course for me. As it stands it’s somewhere between a 3-4/5

This is a good, fairly well-paced course. This course teaches a lot of the fundamental software development processes and techniques that you need to know in the real world but that aren’t necessarily taught in undergrad or other grad classes. I would definitely recommend it as the first course you take in OMSCS and also strongly recommend it if you haven’t worked as a professional software developer but are looking to break into the field in the future.

I have been a professional software developer for 10 years so I wasn’t sure how much I would get out of the class however I did learn some new tricks and techniques in it so I think it is worth it even for people who have done software development in the “real world. “

The class strikes a good balance between learning new subjects in the lectures and testing that knowledge by doing fairly simple programming assignments. The class is paced well and I didn’t feel overburdened except for a couple weeks where we had invidividual and group assignments in the same week.

The group project, like all group projects, is hit and miss depending on the group members you are assigned. If you have someone not pulling their weight it can be a nuisance. That said the grading in general is fairly generous as long as you put forth effort.

This class completely depends on the team.

I took this course while I was on vacation for most of the term and completed it with an A. For someone with hands-on java programming and software development experience, this course should be a cake walk. Also, taking SAAD(CS 6310: Software Architecture and Design) in my prior semester helped skim through most of the UML/Design pattern related stuff. From a learning perspective, Android app development and testing methodologies were some of the interesting aspects. Group project got a little tricky with one member MIA but the remaining two of us were able to get the project past finish line. Lectures, Piazza and Office hours were well planned/coordinated.

Generally I have favorable view of the course. As someone who coming from an optical physics background, I’ve worked on device drivers and algorithm, but there were things that I’m peripherally aware that are missing my background. This class filled in the knowledge gaps in software development process, and pieces of best practices over the years made sense to me holistically. Most of the time crunch will be with the team project. Highlights:

1. ) Learn to develop in asynchronous, distributed team environment using github. Shifting and changing roles.
2. ) Learn to develop android app in 1 week (or less)
3. ) Learn to do simple software architecture with UML tools
4. ) blackbox test interface development with TDD. whitebox test on code coverage.

This course is a hit and a miss. The material isn’t difficult, however I found the marking (especially without a provided rubric) to be highly disagreeable. The group project is also nice - if you’re on a team which knows what they’re doing! I was on a team where one person was essentially MIA for the whole time. This has lead to the higher workload and sleepless nights from my part. I found taking AI and ML less stressful than dealing with the group projects in this course (comparatively when I took intro to health informatics, that group project was relatively pleasant)!

At the rate this course is going - it looks like it will be my first B of my 7 courses in the program. Would not recommend unless it is required for specialization.

This was the first course I took as an OMS student and it was a great introductory course to get used to the framework of OMS (Piazza, Udacity, T-Square).

The assignments and project guidelines were fairly straightforward, though there was a pretty wide disparity in grading leniency among TAs. I’d expect rubrics in future iterations of this course. Best advice I can give would probably be to establish how and when your team will meet/communicate/collaborate for projects early on, and try to keep up with the Piazza threads.

Prof Orso had great lectures and was very consistent with office hours. I really enjoyed the Hangouts Live format of office hours. Overall, great introductory course for the program!

This is my first class in OMSCS and this is a very good introductory class to OMSCS and Software Engineering. I’m working as Software Engineer but I still feel the class is fun and worth taking. It brushed up my git skills and introduced me to Android programming.

The instructor (Prof. Orso) is very active and always conducts office hours every week, he is also always present in piazza (except nearing the end of the semester, when he and all TAs were overwhelmed with grading and grade challenges).

The load is quite constant and I spent about 5-7 hours a week, except for the Android team project, which I spent almost 50 hours across 3 weeks span. But that’s more because I wanted to deliver a ‘nice looking UI’ with a close-to-non-existent Android expertise.

The contents are pretty straightforward and easy to grasp. There is no exam but instead your grade comes mostly from assignments and projects. Having said that if you want to get an A, you have to focus on the details of each assignment and project, making sure to deliver what the instructors expect from those assignments and projects (make sure to attend/play later the ‘optional’ office hours too, as often clarifications are given here - even though usually the piazza also has a corresponding thread). For some deliverables, the instructors may deduct quite some points for non-compliant items, so don’t underestimate the seems to be easy assignments and projects. The grades are also not curved (90+ to get an A) so it is important to get a good grade for every assignment/project.

Overall, it is a great course, and I recommend taking it especially for new students as an introductory course to OMSCS and Software Engineering.

Dr. Orso and his Merry Band of TAs did a great job with this course! The lectures were well done, materials were documented, and the projects were perfectly in line with what we were learning and reflected what was presented in the course prereqs and syllabus (as opposed to my experience in another course).

My only suggestion to future students is that if there’s ever a debate as to whether something is required or “good enough” (documentation, feature, tests, etc) - be safe, not sorry.

Lectures: good. There are also some interesting resources that Prof. Orso links to in the class schedule. Read those!

Assignments: overall pretty easy, (I have ~3 years experience in the software development industry with Java + CS undergrad degree involved a lot of Java). My biggest complaint is that the grading was all over the place. Some assignments were graded harshly while others seemed to only be glanced at. At least for the Spring 2016 semester it seemed that they didn’t have enough TA/graders to handle the number of students.

Group projects: Project 1 was kind of silly, Project 2 was a good first “real” Android app. Groups are teams of four, and your workload will probably depend on your team members. The second project was the most time consuming part of the course.

No exams.

Overall: If it weren’t for the nice introduction to Android I would regret taking this course. It is really meant for students who are new to CS (or at least Java) or have been away from it for a while. I took this class with Introduction to Operating Systems. It was a doable double (A in both courses) but I didn’t get to do as much “reading on the side” as I would have liked. This is the only class I have ever taken (including undergrad) where all Piazza questions were answered.

If you are starting OMSCS program without having good programing skills, I recommend taking this class as the class is nicely designed to cover fundamental elements of software development and you will have opportunities to develop or brush up programing skills through the course. While I had been away from programing for quite some years, I was able to catch up and enjoyed all the material in the class. However, I still recommend some preparation beforehand such as learning basics of git commands and java program through the free Udacity courses if you are very new to the program.

The quality of the class is very good as lectures are well structured and clear. I hear different opinions around project assignments but the class will try to assign a project team with good mix of experience (i. e. balanced) with common available time slots as much as possible. My experience on project was very positive and I felt like I was really in school having a weekly hangout meeting with colleagues.

Opportunity for improvement I felt was the lead time for assignment grades and opportunities to practice white box and black box testings. The class gives some good examples but it would have been nice to go deeper in these area.

Overall, very good class to take and I enjoyed almost all assignments and exercise in this class.

This class is very well run by Prof. Orso. My background is in Python programming and I entered with essentially zero Java background aside from the Lynda course you may use provided by GaTech.

Good: Well run (as stated previously), videos are well produced and the assignments are very clear in what they expect*.

Bad: TAs took an extremely long time to get us our grades. This was very frustrating because rapid feedback is always appreciated. Our class project (#2) depended on one of our past assignments, on which we did not receive feedback. This made it quite tricky to navigate. Additionally, as with any class with group projects, some teammates will be good, others bad.

Takeaway: I learned plenty of Java, and I feel that I’ve successfully polished my ability to use Git well. I would definitely recommend this as a first course to the GaTech program, as it is a good intro to the program’s systems itself (Piazza, Buzzport, T-Square). Overall 9/10.

I enjoyed this course. Although some of the grading felt nitpicky, I think for the most part the instructors were fair. My understanding is group projects could be a crap shoot. Lucky for me my group was terrific and everyone was well-engaged and willing to put forth effort towards each project. This year, two of the projects were group projects with the final agile project being an individual project.

While it’s not a make or break, coming into the class with an intermediate level of Java is probably best.

good introductory class for OMSCS for those who are not familiar with java, eclipse, github or other tools. I had problems because my laptop wouldn’t support Android runtimes, but even bombing that project had time and other projects to make up the grade. The grading was a bit frustrating, losing points for having a comment without the correct capitalization. The projects were fun though.

For the bad: This is the easiest course I’ve taken thus far, and it’s my fourth software engineering course (2nd at GA Tech), and I have a substantial amount of experience coding in Java which helped. However, this will probably be my lowest grade at GA Tech, because their grading rubric and assignment weights are absolutely asinine. They would deduct huge amounts of points for trivial, ridiculous, or even subjective reasons.

They would also derive requirements from posts between students, or from optional office hours (note: there was a special requirements interview office hours, and I’m not referring to that one) and then grade against those arbitrary requirements, which I found to be rather uncalled for and unbelievable.

There’s a lot of group work, and every week some project or assignment will be due, so the workload is very consistent, you will be putting in hours towards this class every single week for the full semester. Take this into account if you have a lot of business trips or plan to take any additional courses while taking this one.

For the good: The lecture videos are some of the best I’ve seen at GA Tech and the android application development was really fun, plus there were consistent office hours on google hangouts every week.

Overall, this was an enjoyable course. The content is a good intro for someone like me with no professional CS experience. Most of the assignments were fun, interesting, and not overwhelmingly challenging. I wasn’t crazy about the group projects because there’s always a roll of the dice with the quality of your teammates, but it mostly worked out ok.

There is one major problem with the class, though: they were extremely ineffective and providing timely feedback for assignments. We had weekly assignments and in many cases it was over a month between submission and when the grades were released. This made the assignments quite a bit less effective than they could have been. Every week the head TA made commitments about when we’d get our next wave of grades back and he virtually never followed through on those commitments. Were it not for this significant shortcoming, I’d say the class was outstanding.

This course was very simple. It introduces you to the basics of Software Development and provides some tools that you would use on a daily basis. Many of the projects and assignments were very simple and took around 3-4 hours per week to finish. The TAs and Professors were very good and helpful.

Overall, an easy first class but none of the material will be new to someone who has worked in the field for a few years.

SDP is an extremely well run course. Alex the lecturer, and the instructors are all very responsive on Piazza. Alex also has office hours every week where you can ask more questions if you have them. The course material is well laid out, the assignments are easy to understand what is required, and the lectures are well done.

Now for the not so good:

• This course is easy. I have only a sliver of a Java background, and this was enough to get through the paper just fine.
• This course covers things like using an IDE and git. If you’re a working programmer like myself, you will probably already know this.
• The grading on the group assignments is focused on the paperwork you produce, not the code. We turned in an assignment that failed half the instructor tests and still got an 80 or 85.
• There is a significant amount of group work in this paper. I was in a different time zone to my colleagues and ended up doing 6am meetings most of the time.
• I didn’t really enjoy the material. The course is about the software development process, not coding, and it covers a lot of tools that aren’t relevant to me as a working programmer, e. g. UML, Rational Unified Process, e. t. c. However this is the point of the course so I shouldn’t be too surprised :)

Overall, this is a good paper to take if you’re new to OMSCS and want an easier paper to start with, to learn the ropes of taking papers. If you’ve already met your foundational requirement, and aren’t interested in more enterprisey processes, and are looking for challenging papers, then I wouldn’t recommend this one. However I must emphasise again, how well Alex and the TA’s run this course.

I loved this class, luckily I had an amazing team. It was fun to create Android application as well. Knowing Java is very important. Facilitating with remote classmates are challenging at times, but with the right communication tools I think it is not too difficult.

This class is necessary. I wish it weren’t. You get to know some important tools. You’re given vague descriptions of a bunch of documents to create. So you google them and make your best guess about what you’re supposed to be doing and fill the page up with as many official sounding words as possible. They teach you just enough to know you don’t know what you’re doing. The grading is the most nitpicky grading imaginable. If you don’t include an exact word they’re searching for you get points off. Getting questions answered is an adventure. Some weeks- no problem. Other weeks you might as well smack your head into a wall for all the good it will do. If you’re assigned a group where people withdraw or don’t have time to do their share, you’ll have to do it all yourself. Expect 15-20 hours if you’re not very experienced and you’re having to do a lot of the group project yourself. Overall, frustrating.

The course allows you to practice many things including working with J-Unit for testing, agile development methods and Android development. Although some of the topics will seem rudimentary if you have been working as a developer, they are taught well and help reinforce many good practices.

This class was awesome! Its not terribly difficult, but you get exposed to many current ideas in software development; you also get exposed to Android programming which is cool as well!

The instructor is probably the best you will see at GA Tech - he is knowledgeable, passionate about his profession, loves to teach / great at teaching, and is fair. The projects do take some time but as long as you are willing to put the time in, you will have no problems.

Take this course!

This class really measures your writing and Java programming skills. If you don’t have experience with Java and JUnit, this class will be very time consuming. The material is not difficult, but project are a challenge (especially if you’re placed on a team with weak Java skills). The written documentation you need to write is extensive, but not challenging.

Great course. I would love more emphasis on agile. I enjoyed the group projects, but this is probably because I was lucky in this regard.

If you’ve already worked as a software developer you should avoid this course. It’s some very simple development ideas and introduction to git and android. A team project makes a simple app.

Or take it along with a tough course to pad your schedule.

This is a good class. The lectures are fluid and linear, and the projects are really good at providing a platform to try out the techniques taught in lecture. There was an element of Android development which presented a bit of a learning curve to some, but generally if you are comfortable in Java then this course will be easy for you. The workload is definitely back-end; the last few projects are group-based as well.

Excellent class. While I have coding experience, I am not a developer, so many of the material and tools we learned were very interesting and helpful. I can understand why some people get bored if they’ve been in the industry for a while. The lessons are fun and the assignments build on whats taught in a way that helps reinforce the material. As for the structure of the class, I feel this is a great first representation of what OMS CS is about. Excellent presence from the instructor and the TA’s. Any issue posted on Piazza will either be addressed by other students or the faculty in a very timely manner. As stated in previous posts the one wild card is the team you get assigned to. The team assignments are definitely the most time consuming and if you have members that don’t participate it could get even more difficult.

Okays class. Group projects are fun. You get to work and deliver projects with your classmates. Prior knowledge of Java is helpful.

I spent many hours in this class compared to others because I don’t have that much experience in Java, Android, or databases. I think I came out alright and learned a lot in the end. Group work is a little frustrating since everyone on my team was on a different time zone, but we made it work. I am most appreciative to be in a hard working and cooperative group. The professor and TAs were fantastic and very engaging throughout the lectures, piazza discussions, and office hours. I recommend everyone to take this class.

Great course on the general development process. I enjoyed the projects, as I had a pretty awesome team, and the individual assignments.

Videos are very, very well done. Dr. Orso was excellent in helping and staying in touch on Piazza. He also worked very well to keep the course moving and fixing issues.

For me, starting fresh, I thought this was going to be an easy class to get familiar with the program, and I was right. I enjoyed the content very much, which was an advanced rehearsal of the software architecture classes I received in college, and the programming portion wasn’t difficult at all.

There was a lot of documentation to write. You need to be ready for it and feel comfortable creating UML diagrams and writing lots and lots of content. This is tricky because your evaluation will highly depend on what somebody else interprets of your writing. In Software there are usually multiple ways to skin a cat, so you need to make sure to show the instructors that your way is a valid one.

The course uses Java throughout. If you have used it before, you shouldn’t have any problems getting by. The material is not complicated, and I enjoyed the different programming assignments. The final project is the development of an Android application, which will take some time. I did Android before, so I felt right at home, but I saw some people struggling because the learning curve wasn’t easy.

During the class, you are part of a team that works the projects together. Teams are somehow hit or miss; there’s usually somebody that does very little to help during the class. If you are unlucky, you can find yourself bearing most (if not all) of the work. At the end of the project, you get to evaluate each team member, which is appropriate and forces people to try to be helpful.

In the end, it was an excellent course, and I loved the material. Although I was very familiar with the topic, I had the opportunity to rediscover things that I had long forgotten. The workload stretched me enough, and I highly recommend it for anyone working in the Software industry.

If you have some development and Java experience before, this course would be very easy. I recommend this course for the fresher to get to know how OMSCS program works.

Group projects tend to increase workload that is otherwise pretty manageable. Not a lot of depth here since the course covers a lot. It’s well-designed though and has a lot of activity on Piazza.

This was one of the first courses I took, and I am glad that was the case. It was a comfortable way to get started. I also enjoyed learning how to develop an Android app.

Hate the group work too. Deciding on requirements with a diverse team can be very difficult. Finding meeting times was very challenging. This class was sometimes more difficult to deal with and fit into my schedule than Machine Learning

Very good class to learn materials. Easy to understand. Time consuming with projects and team works. Get heavier end of semester.

Overall I enjoyed this class, and I was able to apply some of the material I learned immediately. Great focus on practical topics. It was more work than I expected based on reading this sheet beforehand, but that’s probably because I was new to java, git hub, and pretty much everything covered in the course. There were a few times I was frustrated with some of the programming assignments.

My assesment may e a little biased in terms of difficulty becasue I hadn’t ever programmed with an object oriented package. Also, my background is in EE and not computer science. Regardless, I’d say this class is very well structured to let the student understand the software development process. I was lucky and was assigned an amazing team of individuals that pulled together to get everything done. I know of others that were complaining about their teamamates. In any case, I believe that just reflects real life anyway. I highly recommend this class. Ended up getting an A in the class.

Hate group work. Hate staying on group schedules while we are all working and in different time zones and schedules. Interesting course work; hope you get a good group. Better if you have a strong backround in java - you do not want to hope your group mates do. If you do, take the lead in coding right from the start - it’ll waste too much time to try and make it equal, which people tend to want to do - there’s probably only 1 maybe 2 actual coders in your group, and there is a lot of documentation and stuff anyhow.

I really liked this class. Some weeks were very easy, and others had tons of work to the point where I spent my whole weekend coding. I suspect if you are good in Java this will help out tremendously. One of the most important variables is that you get placed into a good group since several of the projects are group based. For example our group worked very well, but many others complained in the forums about issues they were having where some team members were dead weight. Because of this your experience can vary greatly. You definetly need to know some Java going into this class. My knowledge was limmited to one class I took several years back, but was able to catch up quick by taking other online tutorials and READING BOOKs as I went and I Googled ALOT! The last project (originally scheduled to be a group project but changed after complaints about groups) was a solo project and very large. My project ended up being over 500 lines of code. It was a good challenging project and I am a better Java programmer for it. Also learning Android development for the first time was fun!

Great class! You learn some very useful stuff, but it can be pretty intense at times as there is a lot of technology introduced and group dynamics to consider. If you don’t already know them, you’ll be learning eclipse, git (and github), md format, java and android in the first part of the semester. The groups are 3-4 people each, and it can take more time than you expected due to the various concerns of your group members. You’ll find that they approach things a bit differently than you do, so you may spend a fair amount of time just sorting that part out. A bit of real life thrown in! At least this semester the groups remain the same from beginning to end. Make sure you don’t have plans which will take you away from your computer for a long period of time, as it’s heavily group based.

Know java and know SQL. Learning android on the fly definitely a requirment and will make your group members very happy

I liked the lectures and have found the content very relevant. The assignments and projects are straightforward. For the projects, I think a lot depends on the group you are assigned to. I had a great group, so even though we lost one member that dropped the course after groups were assigned we were all active and involved in sharing the workload and it turned out okay.

My first class in OMSCS so it is hard to judge Overall Difficulty. I have a lot of software programming background but very little Java. Some kind of assignment or project deliverable is due practically every week. Only one class project was particularly challenging… but luckily some of the other team members had some strong Java and database experience so they definitely carried the day. Generally good concepts and the assignments/projects helped reinforce the lectures.

This was a good course that covered a wide variety of software development processes and topics. It should be a good primer for the other software development courses. The lectures were well thought out and the presentation was good. The individual assignments can usually be completed in a couple hours (2-4). The group projects can take upwards of 20-25 hours a week. The class originally had 3 group projects, but 1 was changed to an individual assignment by the professor due to various group issues. This course requires Java programming so learn it beforehand or be prepared to learn on the fly (which is what I had to do). You will also need to know some SQL and Android. If you’re already skilled in another OO language it shouldn’t be too difficult to pickup these skills as you go along.

If you are new to java, do not take this class.

Overall, a great first class to take in the OMSCS program. Of course, I was fortunate to have an excellent group to work with throughout the semester. Lecture content was presented clearly, however some things required extra research on my part (ie. Android development, JUnit testing, GitHub usage, etc. ), but hey THAT’S WHAT GOOGLE IS FOR. Prof. Alex and the course instructors are very good about responding to PIazza posts. You DO need an understanding of Object Oriented concepts, even if it’s not Java. I’ve had some Java and C# training (but minimal experience) so I was able to pick up the material fairly easily. I’m glad to have learned some of the administrative and testing components to software development (inc. the project plan, use case diagrams, testing methods, etc. ). GROUP PROJECTS –> As mentioned, I was fortunate to be in an awesome group. However lots of people were not so fortunate. There IS a teammate rating form given at the end of each project because of this.

Despite not having any recent java experience, I found the class very easy. The various assignments vary and some of them you get multiple weeks to work on. The thing that is time consuming is coordinating with your group. There were 2 group projects this semester and testing/documentation are part of the projects, not just coding. If your team works togethter, you don’t have to spend a lot of time on the project. I know other comments have mentioned the database aware app, but you get 5 weeks total to work on it between your team members. Our team finished in 4 weeks and didn’t actually need the last week but I know some people did.

Difficulty and workload definitely depends on the teams. My team was awesome and we were able to accomplish a lot together. I was in charge of main development. Workload will be more during project weeks. Great class to get started.

I have a difficult time figuring out who is the ideal audience for this class. The first few weeks cover ‘this is what an IDE is’ and ‘this is what source control is’, etc. - stuff you would expect in an undergrad CS101 class. Other topics are very advanced, like ‘write a non-trivial database-aware Android app in 2 weeks, including test cases and other stuff’. It seems to me like anyone who was new to the former is going to get completely sunk by the latter, and anyone who is capable of the latter is going to be bored out of their skull by the former and then be surprised by ‘oh… we actually have to work in this class!’ halfway through. For this reason, I think the class should be split in two, so that people can take only the portion that is relevant to them. I’ll echo other commenters’ statements about group work - do not like it, and in the future will only look for classes that involve solely individual work.

I thought this was a great class. I’ve been doing professional development for over 20 years and honestly didn’t really expect to learn much…. however I did (and a few things I had forgotten from the past got reinforced). I thought the professor’s lectures were extremely professional and actually entertaining. Online resources including Piazza, Google Hangouts, and regular office hours from the professor and TAs also helped. I’ve taken four other graduate courses online at another school and this blew those away in terms of quality of content, interaction with other students and staff, and sophistication of projects requested of us. As an aside, I want to note here that anyone taking this course should invest in learning Java fairly well before diving in. It’s a poor excuse to be taking an MS CS course but claim you’re unable to do the project work because you’re not a programmer. This is CS - it requires coding skills and this course definitely utilizes those skills. Just be glad it’s Java and not Lisp or Erlang….

This class might be easier if you already have professional software development experience, but I still learned useful skills and overall enjoyed the course. My group worked well together although based on the discussions this wasn’t always the case. You should not take this course if you new to programming or cannot figure out how to use a search engine.

I did not get much out of this course and didn’t enjoy the experience very much. The material explored many topics but none of them in-depth, in some cases were just basic tutorials for tools like git and Eclipse. The assignments felt more like jumping through hoops rather than being challenged to think critically and be creative. Overall the course felt disorganized and vague, most of the time I was not confident that I actually understood what was required and had to read a lot of forum posts for clarification, even on extremely simple busy work assignments. The most effort in the course is required during the group projects, which can include students anywhere on a spectrum from not being able to write code at all to having 10+ years of Java experience. A lot of groups had problems and partially due to that the last group project was changed to a solo project at the last minute. I think I would only recommend this course to beginners who are confident that they can write Java code but do not have much software development experience beyond that. If you know absolutely nothing about concepts like source control, test coverage, and UML then you will learn a lot. If you already have a lot of experience in software development and want to explore software engineering concepts higher than a very basic level, this course is not for you.

Great introductory class for the OMSCS program. Well structured, with interesting projects, both individual and online. The Professor and TAs were very involved. Even though I has many years of experience in the software development industry, this clas kept me interested and learned a few tricks as well. You will need a bit of Java, nothing too deep.

I think this class was very simple for a CS major or someone with a previous background in the subject. But you should be comfortable with Java or C# before taking the class. I think the class could have had much more material and be more rigorous. Since I have quite a bit of industry experience I don’t think I got a whole lot of new knowledge. The assignments were simple the only problem being coordinating with your team. In the end some of the projects (like Project3) just seemed like busy work. I think it is a good class to get you warmed up for the harder classes in the program. The Piazza forum had some interesting discussions going because of the variety of student background in the subject matter. The professor is very responsive in the forums and fun to watch in the lectures.

Very intersting class, and useful to those with little background in Object Oriented Programming. You get exposure to Java, Android, SQL, OO software design. If you already have this kind of background, the class should be a breeze. If not, there will be some catch-up, but it’s not such a big deal. The one hickup to this class is that your experience will depend heavily on what group you were placed into, as the second group project was somewhat complicated if you don’t have prior Android and SQL experience. The individual assignments are all very straight-forward and not time intensive.

Great class for the OMSCS program, well organized and the Professor and TAs are very involved. I already had some years of experience in software development and I still gained a good amount of knowledge. This class will give you the foundation so you can go deeper into software development processes so don’t expect to be able to run a team of develpers, planners, testers, etc. just by taking this class. I say this because some people complained about the content of the class. If you don’t have prior experience with software development and Java programming, you may need to spend a lot more time. Also, there was an Android project which I think it wasn’t too bad but some people complianed about the need to learn a lot of things in a short period of time. The workload will increase towards the middle of the class since you may have individual assingments due while you are still working on a group project. Overall, I think this was a very enjoyable course.

Material and leactures are great. Very helpful. The group projects (if you have a good group) are fun and you learn a lot. I do felt like I spent more time learning about the frameworks and less on the formal process, however learning frameworks is part of the overall process :)

I agree with the views regarding the group project. I think that some students were not qualified to take this class and caused an uneven distribution of workload. The other problem was that with a rate of drop out around 20%, the teams that were formed early on in the semester were subject to change. For us, the guy with the Android experience and skills dropped out of the progam and this made it difficult for us to work on the team project. The professor is enthusiastic and the material like testing, GIT, etc. is very relevant so someone new to all this will find it helpful, but those who already use and do such things for work may get bored.

Lecture material is very simple and easy to understand. If you have any industry experience in software development, the concepts should be very familar. Group projects are where the fun is at. Projects require you to develop some software apps (all in Java, two commandline, one Android and one web). You might get paired with people in different time zones so cooperating might get difficult. We had two people drop out of our group which made things stressful. But very quickly you learn to assess each other’s abilities and split up the work so everything gets done. I had prior experience in Java but no Android experience and I was able to pick up Android pretty quickly and be productive. I really enjoy programming projects so I really enjoyed this class. Best class I have taken so far (As of writing, I have taken four courses total)

Reiterating an earlier comment: ‘I have a difficult time figuring out who is the ideal audience for this class… ‘ I couldn’t agree more. Lectures were average, but I admire Prof Orzo’s enthusiasm. Group projects were terrible - if possible I will never take a group project class in this program again. Students should have to pass some coding pre-reqs to take this course because unprepared students are a huge burden on teammates; ‘just’ working on documents is no panacea because if they aren’t involved with or don’t understand the difficulty of implementing requirements, it hurts the entire team. There is zero involvement from TAs in managing group conflict, and no real authority structure to groups. We had a team member who refused to do any coding but argued for adding more features than the assignment required. I don’t need that kind of drama.

This course taught me a great deal about testing and team dynamics. I suspect a lot of your experience depends on the group. My first group worked very well together. The second group (for 3 projects) had lots of late night meetings that moved slowly. (30 hours per week worth) A big part seemed to be busy paperwork but maybe that was just the group I was in. It is very Java oriented and the Android emulator was brutally slow on my machine which made that section tough to deal with.

This was a great course. Very informative. Work was doable but the last Project would require some extensive understanding for Java Programming.

The professor was very involved. The TAs (who do the grading) sometimes do not follow the grading rubric, so we had to request a few regrades. I did learn alot about Android Programming, GIT, and JUnit. This was more easier than 6310 Software Architecture and Design.

Excellent engaging hands-on prof. TAs were well organized with an excellent synchronization of ‘one-voice’. Even if you’re an experienced programmer, you’ll learn quite a bit in this course.

Pretty easy material. But, depending on the role you play and group dynamics, it can be a lot of work. If you are an experienced Android dev, you’ll find it easy. If you’ve never used Java, it’s going to be tough. Also there are a ton of design documents to produce and grading wise these are as important as the code, so don’t underestimate them.

Group projects are NOT GOOD! Only a couple of team members have to work on all projects and it affects the final grade.. make sure to do all assignments on time and learn Java/Android before you start this class

Lets start with the most common complaint in the class. Too much programming. I do not agree. The programming was very light and very reasonable. I believe if you have trouble with the programming in this class, that may be a sign to find a new major. I haven’t done much Java (mostly C#) and I had no issues translating between them. The other complaint is about group work. I imagine this depends on your group. I had a great group. 3 programmers and a professional PM. We spent a lot of time together, which was the hardest part, but we worked well together and I learned a lot about group work. Some weeks I spent very little time in this class. The start is slow and was a little boring, but when the group projects started I spent quite a bit more time talking to my group. We likely didn’t have to, but we did. The lectures are entertaining and insigtful. They do a good job of creating interest and are a good starting point for further learning.

Overall, this was a good course, but IMHO is mainly due to the level of involvment from the professor and TAs. The content was decent but I would have preferred much more focus on Agile. Knowledge of Java would help but anyone with reasonable coding experience in any language should pick it up quick. My one serious concern is that, though the team projects did take some significant time and effort, the individual assignments were relatively simple (but also fun and good learning tools). However, it seemed many students made them much harder for themselves than necessary but you couldn’t help others too much in that respect without violating the honor code. I think KISS and YAGNI should be part of the lesson plan.

If you have experience in Java development, this should be a pretty straightforward class. The most difficult part of this course was coordinating with your team for projects 1 and 2. The programming assignments were usually pretty simple and could be knocked out in one sitting. Overall, the course was pretty enjoyable. The lectures were extremely polished and thoughtfully designed.

Found it easy but I have 10+years of experience in software development. Course is very organized, teaching team is excellent and touches a lot of tools of the trade. The empahsis on the importance of software testing is biggest take-out for me from the course.

If you do a little prep work in java and SQL this class will be easy. Look into the coursera classes to help you prep. Not a lot of time is required to do well in this course. If you are just getting back to school after a large break this class is a great starting point

Easy but fustrating assignments. Basically a lot of documentation and a few, 3, java projects. TAs kind of dropped the ball in semester.

I enjoyed this course. The professor and TAs were very involved, which was a nice contrast to CS6250. Lectures were interesting, and assignments/projects did a decent job of letting students practice the development process concepts we were learning about. I came in to this class with 6 or 7 years of. NET development experience, but no Java/Android experience. I had to spend a little extra time on the assignments to transition my. NET knowledge over to Java, but it was easy to do so and the assignments are relatively basic. I would think that someone with zero programming experience would want to take a quick intro before jumping in, though. There were two group projects in this iteration of the class, which I’m normally not a fan of but they complemented this class nicely. Good simulation of working as part of a team in the real world. I felt like the way they handled grading the team vs. individual contributions was fair. I had a great group that had no problems working together, so I’m not sure how any serious conflicts within the team would be handled if the professor/TAs had to be involved.

This class was AWESOME. Made me a better programer. Alex Orso is a really good teacher that knows how to make an interesting video lecture. Class wasn’t to difficult and I liked learning how to make android apps.

Great class! You learn a lot of industry best practices, and a lot of useful tools like java, git, android, and project management. Assignments usually took around 8 hours, except for group projects, which could run around 15 hours. Lectures are clear and concise.

Wonderful instructor, great class dynamic. My team worked well together, and we were able to parcel out tasks and time to meet, so we didn’t have as many issues as other teams did. Projects are very straightforward, and if you’re comfortable with Java, you should do well. My only difficulty was learning the hooks for the Android project, as I’d never done that before.

Prof Orzo is very cool. There is a decent chunk of work to do most weeks, (especially if you plan to take over the summer). I am generally not a fan of group assignments, but I was lucky enough to be assigned to an awesome group. Even still, there was overhead in scheduling meetings and whatknot. Overall, I would definitely recommend taking this course and think it is a doable amount of work for a summer semester. P. S. A couple of students had issues with the way that ‘extra credit’ items we rolled into the final grade (somewhat ironic since the final assignment was a ‘Student Grader’). As such, I would recommend doing ‘extra credit’ tasks whenever possible as many of them were pretty straightforward.

The major programming assignments were group-based. So your experience in this course depends to a large extent on the group you were placed in. I had a great experience with my group however I am aware that this was not the case universally. GATech make an effort to place at least one experienced Java dev in each group so even if you are not particularly strong in programming, you can fill another role in the group such as testing and/or documentation. There are individual programming assignments as well however these are considerably easier than the group projects. The overall progression of the assignments simulated a typical system development lifecycle project (with a RAD twist) with all the associated deliverables; systems requirements doc, prototype, test case doc, UML model, user manual, etc. I found that it was possible to deliver the assignments without really watching the lectures however part of your grade is based on your completion of the udacity quizzes so I guess this encourages you to watch all the lectures. This is a great course to ease yourself into the OMSCS program.

I took this over the summer. The projects are team-based, and I ended up doing a huge amount of work. The content felt dated and too OO focused. The instructor is awesome, but the course is meh.

The content was a bit outdated IMO. Professionally not many places use formal UML modeling anymore and I think there was too much emphasis put on formal documentation to be truely representative of the real world. The individual assignments were okay (not too difficult) but they were looking for a very specific way for them to be implemented which in my opinion were just bad design. The course instructor was one of the most engaging though which made it an alright experience. As others have commented the group work is awful, there is such a huge gap in experience and certain team members carry the lions share of the burden. I understand it’s trying to represent ‘real-world’ work where you have to collaborate with a team, but in the real world you don’t have people with so little programming experience who are still gainfully employed, and quite frankly the ‘project-manager’ role for the project doesn’t have an equitable share of the work.

My java skills were entirely not up to snuf. I thought this class would focus on the process and wouldn’t require so much ground up coding. I seriously had the best group ever but even that’s hard because you don’t want to let people down and the coding just required more time than I had to spend. I will try and avoid classes with group projects from now on. In terms of grading, even when I thought my submission sucked, I got a decent grade. Even not knowing enough java, I would have gotten a B on my own but my awesome group assignments pushed me to an A. I hope in the future they reconsider that Android app project as it is just way too much in that short time (maybe extra crappy due to summer?)

Know your Java. Android assignment hadn’t been done by staff with the version we had to use. It and Git needed more attention. Simultaneous deadlines. Other than that, I feel good about the course, i. e. , the Piazzan esprit de corp, videos (Orso & clever cartooning), challenges, and teamwork. Learned alot, I believe.

Good exposure to a variety of tools. Assignments should be done by staff first to make sure there are not issues. Course grading should have been better defined.

Easy material if you are experienced in developing software but the team projects were a lot of work. What ended up happening is you are paired with people of varying levels of skill and if you are more experienced, you end up doing almost all of the work. If everyone did their equal share, it probably would have been 5-10 hours a week but since that isn’t realistic, a lot of weeks I was stuck doing almost all of it which is a good 15-20 hours. Earned an A in the class

The documentation portion of the class is awful. Seriously. Lets make a full class diagram, use case model, component diagram, deployment diagram, and mockup UI for the most basic application you’ve ever worked on. Makes you wonder how people swear by UML. Overall though you learn a lot. Especially if you’re new to SDP

If you are new to programming or to Java, this will definitely be more challenging. It was fairly easy for me because of many years of software development experience. I especially enjoyed the Test-Driven Design element of this course as well as the introduction to agile development. The professor and a couple of the TAs were very active on Piazza and there were several good discussions. The course was well organized and the assignments and expectations were well defined.

If you are familiar with java, it should be easy. It is a interesting class and you can learn a lot.

The testing requirements are a little more ‘elaborate’(you have to answer all the quizzes on udacity, which makes it hard to download the lectures and watch them). The grading requirements for a project/assignment are badly defined, by design. This is to stimulate real life requirements, not something I particularly enjoy but I understood the need. Group projects were fun, but I suspect this depends on the project partners you get. Mine are great so it was pretty easy going

Eesh, I really hate group projects. In this case, we had a team member who was pretty much non-contributing, which is just totally lame. I’ll be on the watch for classes with group projects in the future, and I’m going to try to avoid them. What a pain.

Some weeks were more and some less of course, depending on schedule. Group projects aren’t my favorite either but do make a certain amount of sense for this sort of class. Lots of busy work but not too much that is difficult if you know Java. Liked the course better than I thought I would and got more out of it than I thought I would (my career has been SDP… but just goes to show you CAN teach an old dog new tricks).

Very much an intro-level course, you’ll dabble in a couple of different testing and design options, work on a few Android apps. The group projects seem to vary from person to person, but I enjoyed mine. Those were certainly the most time and labor-intensive parts of the class. On other weeks I could sometimes spend as little as an hour getting an assignment done. Enjoyed the class.

Agree with most everyone above me. I thought this was a very easy intro class for Graduate level. The most time intensive part of the class was regarding to meeting with my teammates fro group projects. I luckily had a wonderful group and everyone did their part on the projects. The difficulty level on projects and assignments were quite easy, especially if you watch the lectures. There was only one issue with an assignment due to semantics but was graded fairly by the professor. This class is more focused on the documentation more than the actual programming itself. The latter part I found quite trivial and this was without any java experience. Pretty much if you watch the videos you should get enough knowledge on how to do the assignments and it should be a pretty easy A.

Not too much to add, it was the first class I took in the OMSCS and I was bored. I did get some good info design strategies. This could definitely be a 2nd course for a 2 course semester