CS-6310 - Software Architecture & Design
| SAD |
Toggle to Select Spcific Semesters
Reviews
This course is a great intro course to the OMSCS program. This was my first course and I enjoyed certain aspects of the course, but did not enjoy the readings which seems to be long and necessary. There are no exams, which can be a plus, though there is a group project element. Personally, I had a fine group to work with, but I can see how it would go awry.
This class was weird. The first 70-80% was very easy. The final group project though, worth a lot of points, was incredibly hard. They gave little information on it, but all previous assignments we were told were building up to it. They had us plan out in Assignment 4 what to do for Assignment 5 (the final project), but we didn’t know what Assignment 5 would be.
The problem is that the hardest parts of the course are the actual developing and coding, and the architecture stuff is easy. Thankfully, at least the architecture stuff is worth a lot of points. In order to achieve our dream architecture, my team had to learn a lot of external, 3rd party pieces of software from the ground up in less than 3 weeks, which was unnecessarily hard for an architecture class. I crammed basically a whole semesters worth of learning in 3 weeks, and the other weeks of the semester I hardly learned anything.
If not for the sake of 500$ that I spend on this course, already wasted effort and the eagerness to finish the degree a bit early, I would have dropped it just before the deadline. Such is the quality of any aspect of it:
- Lectures: The professor just reads the text and the content is completely useless. Pretended conversation with a student was so pathetic.
- Quizzes: Ideally, lectures should explain concepts and quizzes would test student’s understanding of it. Having the questions to be highly subjective and exactly the same as that present in the lectures will only make the students copy the answers. I did the same and the experience was awful (Hint: it contributes to only 1.5% of overall grading. OMG, I should have skipped!)
- Assignments: In my experience of more than a decade in a variety of software engineering projects, I would have used UML utmost a couple of times. And having about 50% of overall assignment grading on these useless diagrams is simply awful. In every other course I have taken so far, I have learned something mostly via assignments, but it is ridiculously useless and annoying in this course. Only thing I learnt was the existence of PlantUML which also turned out to be a mistake because the TA cares more about color, layout, symbols than the content (Hint: Don’t use OCL in these diagrams). Not all test cases are provided before the grading results are available for coding projects. Who writes
Architectural Decision Records? WTF? - Group project: Given that most students target this course for its easiness, it may fall on you to do the heavy lifting if you don’t act appropriately. Though the end result was fruitful, it ended up this way for me.
The only reason I took up the course is to pair it with another and the comments on several reviews and conversations with former students that the grading is lenient. But as some reviews suggest, be aware that it depends on individual TA. I ended up with a horrible one and if not for the grades given by them, you may end up frustrated by their early comments and responses in regrade requests. Luckily, TAs change for individual and group project and that pretty much saved me to get an A.
The biggest lesson I learnt by taking this course is that it is better to take relatively harder but highly rated courses at a slower pace.
This is a very sad course. TAs are not responsive, grade reporting is very delayed, course lecture video is terrible with outdated content. Group project is annoyingly time consuming. This was my 4th OMSCS course, worst so far. I would rather spend time on more challenging but meaningful courses with healthy interaction with teaching team. Assignments are written so vague that no way to start without lengthy clarification. Do not take this course just because it’s easy. It’s total WASTE of TIME.
My background is in CS and I work as a full stack software engineer.
The UML diagrams and the lectures were the worst. The group project is entirely dependent on your teammates and I lucked out so that was actually the highlight of the course for me. Heads up, you don’t have to use a database, can just write data to JSON files if you think that’s easier (we did). The Java part of the course was fairly easy given I use it daily. If you’re thinking about taking this class as an easy A, just remember that you have to do 30 lecture quizzes repeatedly until you get 100%. Making the UML diagrams for the assignments can also be annoying. The lecture videos are not good at all, though Instructor Moss > Professor Rugaber (lecturer) so definitely reach out to Moss in office hours whenever you need anything, he’s really helpful.
Nothing in the class matters except the final project. Quizzes/assignments are all very easy and straightforward but your group project will make or break your grade.
TAs are not responsive at all (you get one assigned for your group project), and are also very unhelpful when they do respond. Literally waited nearly a week for the TA to get back to my group and tell us “Uh yeah sure whatever”.
Don’t go with a randomly assigned group, you will be unceremoniously crammed in with a bunch of people who don’t know how to code. Had most of my team proceed to participate in meetings and claim tasks and then do nothing the entire semester (even up until due date). At least tell your team if you don’t know how to do anything or won’t be able to do your task.
Not worth taking this class even if it’s “easy”.
Yes it is very SAD indeed. Got a bad group filled with non cs people ugh ended dropping grade to B. Avoid non cs people like the comment below said
This is definitely not an easy class. They throw you into the loop to build an individual project expecting you to program a whole java applications satisfying 10-20 requirements –word for word in each print statement. If you dont have a good group. Good luck, half the class are non cs majors. Final project will make or break your grade. TAs take a month or two to grade so you dont know where you are in the class. All the easy reviewers are OMSCS students who are halfway through the program and already took much more advanced courses –so they are coasting this one.
The lectures are also irrelevant and very dry.
#1 Tip: Avoid non cs people at ALL cost ESPECIALLY if it’s their FIRST semester at OMSCS. Ask them this before you let them join your group!
It’s not worth the risk taking a non-cs! It will determine your grade (group project is like 40%) !
Extremely boring and tedious class. Its like the creators deviced the perfect way to make a class thats both easy and annoying at the same time.
The lectures are as boring as they get, and they go over so much unecessary detail that is completely outdated. I have worked in top-tier tech companies and people there use maybe 5% of the things explained in this class. Then there are lecture quizes which you will most likely brute-force because you have unlimited retries and its impossible to get perfect scores the first time, because they ask things like: “select all answers that apply”, and then there are like 20 different checkboxes which you can select.
The assignments are tedious as well. Make uml diagrams, make sequence diagrams, go back and fix other people uml diagrams. Then there is the individual and group project. The individual project wasnt bad, but the TAs graded them so poorly. The TAs, just like you, didnt care at all about this class, so they never answered any emails, took ages to answer anything in Ed discussion, and graded assignments by glancing at them and then giving it a score without paying any attention, so many students had to ask for regrades. Then the group project, where you are matched with 4 other students, who took this class just to get an easy A but who have horrible coding skills. Have fun fixing your teammates horrible code while dealing with unresponsive TAs.
This class is pretty bad and its in grave need of a rework, but if you are looking for an A, then this may be one of your few options to take. But if you are willing to put some more effort and actually learn something, I’d recommend taking anything else. I was not, so I do not regret taking it, but i wish it wasnt as painful as it was.
I learned the most from the group project of this course. And the peer reviews of my assignment are very insightful. In this class, you will probably learn more from your peers.
The course videos are dry to watch. I found the textbook Applying UML and Patterns by Craig Larman is more entertaining.
I did not know about Java before and learn that on the fly, it is manageable. I would recommend using Codecademy.
Our final project builts on Java spring boot and mongo db, and demo using the Swagger UI . MVC and DAO pattern are used in our project as well. When working on unfamiliar technologies on the fly with others, I found UML diagrams are helpful for me to understand what attributes, operations and connections to take care of. It is almost impossible to remember the whole architecture in mind.
On the downside, the TAs and instructors are not as responsive as other courses in the forum. The final project took us 21 days. But it is likely we will have no feedback. Nevertheless, it was a great experience to design and deliver a software engineering project.
I have mixed feelings about this course. I was excited to take it because I thought I would get a chance to learn in depth about different design patterns, something that seems important but also an area where I don’t have a lot of experience. Actually very little of this course was about patterns – which in itself is more a demonstration of my own ignorance than a fault with the course. The subject of this course, overall, is the considerations that go into designing software systems from the initial requirements phase, to the analysis of those requirements and the production of models, to the implementation, and then to the incorporation of “non-functional” concerns like reliability, scalability, etc. The assignments mirror this structure: you’ll start with a description of a system and be asked to produce a diagram of the system using UML, then you’ll implement the system, finally you’ll work with a team to extend the system to address additional concerns both pre-assigned and of your own choosing. Alongside the assignments are lectures that discuss different design considerations, different kinds of diagrams used for modeling software structure and behavior, and different ways of assessing design.
First, on the difficulty: as others have said, I don’t think it’s fair to call this an “easy” course. There are no major challenges in terms of algorithms, it’s true – and you won’t be cursing under your breath trying to synchronize threads or deal with double-pointers as in GIOS. But there is a good deal of work involved in doing things right, the assignments are, as is typical of this program, vague, and the group project introduces its own synchronization challenges which, if anything, can be more frustrating than synchronizing threads. I guess it’s possible to half-ass the assignments and get by if you have a good familiarity with Java and a smattering of UML (or just common sense about drawing diagrams) – but you can find yourself quite as stressed, if you are trying to do a good job on the assignments, as you would in any course. And the Summer schedule is compressed, so that adds to the overall load.
I think the idea for this course is good, and the projects fit nicely into that idea. I guess the major issue is the execution. There are weekly office hours, but they become pile-ons for logistics and “what do I have to do to get a good grade on this assignment” (not to say that isn’t a fair concern), so they don’t do much to make the content engaging. Some TA’s (this semester the heroic Pablo Gallastegui and also Eric Weinberg, along with some others) are present in Slack and will answer questions. But … for a subject matter that could be very interesting – how do you design good software systems, and how do you KNOW what makes a software system well designed – I just feel like the intellectual engagement isn’t there.
Part of the problem here is in the supporting structure, as usual: the professor who created the original lectures is gone; those lectures are … OK, if at times a bit hokey, but I don’t feel like the professor is super enthusiastic in his delivery of the material – often it seems like he’s reading notes that are well organized but ultimately formulaic. There are sort of “theatrical” bits that come off like attempts to bring interest into material that should be interesting in itself. There are a lot of readings around the lectures, but I got lazy and skipped some of them – even though the ones I skipped were not bad, one of them even seems quite good. That is because around this shell structure the new instructors and TA’s have erected a series of reading quizzes. The readings for those quizzes are OK, and the quizzes themselves aren’t hard, but it feels like they pull in a slightly different direction than the original lectures, and they are what is assessed. Yes, there are some “practice quizzes” tied to the original lectures and those are just…awful. You have to do them again and again to get 10/10 (well you really don’t, but the syllabus at least says you’re supposed to do that) – and in the end you might have 10 attempts and just be praying not to have a single-word answer quiz come up that you can’t divine what it wants. One of those quizzes I failed again and again until I realized I wasn’t capitalizing the single-word answer. Not conducive to learning!
So I think this course has some good ideas, some good projects, and a potentially interesting subject area. The problem is it really just is trying to do too much and is hanging on to an original structure it has outgrown. I would like – in this course and in other OMSCS courses I’ve taken – to go deeper into one area of the subject matter, to have some assignments that experiment with deeper student engagement, and to have less of a feeling in myself and other students as we go through the course, “What do I have to do to get full marks here?” There’s potential in this course, but there are also a lot of frustrating aspects, and in the compressed Summer schedule, it will make you wonder a little bit why you’re going back to the basement of your apartment to work through another reading quiz rather than sitting out with everyone else at the restaurants and bars and enjoying the summer evenings.
This class is great for pairing with another course due to the highlighted simplicity noted below this review. Overall I actually thought the projects were pretty decent and liked the graded quiz structure. If you are ok with Java and object oriented programming you won’t have any issue with them.
The practice quizzes were a huge pain, however, and more led to a waste of time then a learning experience. The modules could additionally be compressed into about a third of the content as they are highly repetitive. Lastly, they need to speed up grading on the third project as it is related to the final.
Took this with SDP and felt it was a fairly balanced workload for anyone taking 2 classes in the summer semester until the last few weeks.
Ultimately, I actually enjoyed the assignments overall, but the course videos are drier than the Sahara with participation quizzes that go into the participation grade (10% overall). I actually enjoyed the individual/ group project and felt it was a decent look into OOP.
Grading is incredibly slow. We had to do the group project without the previous two individual implementations actually graded. More than slightly frustrated closing out the course with almost 70% of the overall grade still not put in.
DO NOT TAKE THIS CLASS. I can sum up this class in 4 words - “Plan before you code” . You will spend a ton of time doing UML diagrams and learning nothing useful whatsoever. Please save your time and take a better class.
I know some out there are reading this thinking that it’s an easy A course, how bad could it be. I went in with that mentality at least and ended up dropping because the material is more bland than reading an encyclopedia. I’m not sure how other companies handle software architecture but I find it hard to believe UML has widespread acceptance considering how many details are embedded into it just to understand the symbology of it all, or the monotony of creating diagrams. I had taken a similar course before that focused on creating a whole model package more than just focusing on certain kinds of diagrams.
The participatory quizzes are tough to get through to get 100% your first time around so you just end up guessing after enough tries until you’ve wasted more time than they’re worth.
The overarching project concept shows potential to be interesting as it’s gathering how you break down a multi-faceted real life problem but unfortunately the homework does not accurately reflect your ability to process this information and is caught up in UML symbology too much. I didn’t think the grading makes any sense either. I received a mediocre grade on my first assignment because my diagrams were overly-complicated and yet I’m positive I reviewed others’ work that looked like it could have been pencil-whipped in an hour who most likely received a better grade.
By the 3rd assignment (the second is peer reviews) I just had no motivation to continue watching boring lectures, reading about material I apparently was not interested in, or continuing for what I think is little practical knowledge gain. I’m usually happy to take drier courses if I learn a little bit and they’re not too intense, I should have taken the previous reviews on here more seriously.
This class is horrible. The lectures are so boring and really hard to get through. The quizzes make no sense half the time and just add to the frustration of the class. You have unlimited attempts, but it can take 5-6 times to get 100% which is a huge waste of time. I truly feel like I will never use anything I have “learned” in this class. I’m about halfway through the semester but I want to drop the class so bad. Overall, it’s easy so I’m going to try to just push through, but honestly rethink taking this class if you are considering it. It may be an easy A but it is not worth it in my opinion.
What an absolutely miserable class. You may think to take this class for an easy A, but it does require some amount of brainless work - but it is work nonetheless.
The lectures are incredibly repetitive and boring, and we’re “required” to watch them all. I let them run in the background while I bruteforce the lecture quizzes (unlimited attempts, not for a grade but part of the participation points)
I can’t emphasize how useless this class is so far. I wish I had taken something that’s just as easy but useful. I’m not sure who this class is directed towards, maybe folks working at legacy software shops that believe UML is the way to design software?
In any case, avoid this class. It’s truly not worth the time, money, or effort.
From the comments, I thought this class would be an easy A but I underestimated how much willpower it takes to do assignments, lectures and quizzes that are so pointless, and boring. I had 100% but I ended up dropping after 4 weeks because I couldn’t take any more. I would rather have a W on my transcript and get to take another class before my degree is done.
This course is an example of how to waste your $800+ tuition. Useless lectures with boring quizzes and assignments. You won’t learn anything useful. Super unorganized course, they decided to not use piazza and instead use Canvas Discussion which was a disaster. TAs not respond to questions just made it even worse. Very slow on grading assignments, the group assignment grade was released on the last day before grade was due, and don’t expect to get any useful feedback from TA. Inefficient office hour, lots of useless information to listen through.
I see lot of “very easy”, “boring” etc reviews about this course. However, I would like to emphasize that this course is not about your programming/coding skills or about the effort required to complete your assignment, but it is about making architectural decisions.
With my almost 21 years of commercial experience of building software, I have to say that this course is a “summary of my personal style for the building software solutions from the scratch” based on my personal mistakes and challenges I have experienced in the past.
So, if you are at the very beginning of your career, this course might set a vector/direction on your vision for how to architect software solution, and avoid very rough issues around that. If you a already have years of experience, it just will just help you to “polish/brush” your already existing knowledge.
Again, the course is based on the material from the early 2000 and eralier time, when it just started to get a primary focus/shape of all “already known these days” methodologies and approaches on how to architect a software solution, so you will have an idea about the reasons why it is important to define, build and follow the process.
This course definitely will not add any points to your “coding” skills, but it is very useful about the decisions you make when architect your software solutions.
Probably the most boring and useless class I will ever take but hey, as you can see from the reviews, its an easy A. All the assignments, minus the group project if you have group members that are dead, useless weight and wonder how they even got into this program in the first place, should take you no more than a day or two to complete. Lectures are the absolutely useless so dont waste time on them. You can take quizzes twice with the same questions, so it basically guarantees you get a 100 on all of them. Overall, find a good group in the beginning and plan to do a whopping total of 20 hours of work from the projects if you have previous Java and software engineering experience.
Pros:
- Very easy
- There are some interesting readings regarding architecture
- Very easy
Cons:
- Lectures are terrible
- Since there’s so little work, you aren’t incentivized to learn much
- Barely goes into architecture
- You need to sift through a lot of pointless office hours / forum posts to get useful info
Tips:
- Form your group ahead of time, otherwise you risk (guarantee?) getting a crappy team
This course feels like it was written in 2005, and no one has thought about how the fields of computer science or software engineering have changed since then.
Probably the most miserable class so far.
This is my fourth class of the program.
If you’re looking for an easy A, then you’ve come to the right place. If you want to actually learn something, pick another class.
it’s literally ALL UML, no useful information to be found here.
The 95% of the class is graded off of 6 quizzes and 7 assignments.
Quizzes:
The quizzes are stupid easy and you can do them twice, with the same questions. Do the math.
Assignments:
Of the 7 Assignments: 3 are done individually, 2 are as a group, and the other two are CATME surveys. They all tie into each other in making something, this semester was a streaming software business simulator.
-
The first assignment is making a class diagram of the service. Doesn’t need to be right, or even good.
-
The second is peer reviewing other peoples. Again just need to add comments.
-
This is probably the assignment that took the longest. You do an individual implementation. Assuming you know Java and OOP (this is a masters program) you can throw something together in one sitting.
-
CATME Survey for forming your group
-
A team diagram. Basically you’ll take whoevers Assignment 1 you like the most, throw a few extra things on it and turn it back in
-
A group implementation. All the group implementation is over the individual one is a few additions. The work is easily spread among your group and assuming you have a decent group ( I did ) it will be very easy
-
Another CATME survey
The Lectures
The lecture in this class are just straight garbage. I don’t like how the lecturer talks, and whenever he brings in his guests he acts like they’re the dumbest people to have ever walked the earth. The content is disorganized and repetitive, at least the lectures have some decent production value. Each lecture has a quiz at the end which may or may not count for a lot of points. I generally let the lectures run in the background while doing something important.
The lectures are 95% UML, despite expecting you to work in a group project, collaboration tools, and other development processes are barely mentioned.
Also this is the first semester they decided to use the discussions tab inside of canvas instead of Piazza, and I never thought id say this, but Piazza is so much better and I wish more than anything that this class used Piazza. The Canvas discussions page has no organization and it was impossible to find any information about the class issued by the Gas
Overall I say 1 hour a week because there were many weeks where I did nothing but let the lecture run in the background, its an extremely easy class to pair with something else, and if you’re looking to grab an easy A, its the low hanging fruit.
Easy A class and helpful to do rewind of Java OOP.
4th/5th class (taken with GIOS)
Overall this course, was a tedious and good intro class to the program.
I would say the UML class diagram assignment, the individual implementation & group project were the more cumbersome parts of the semester. The quizzes and participation points were easy freebies.
Although some weeks required more dedication due to granular things that you may want to improve when working on any assignment, it is a good class that teaches you to design code before implementing it, which can be somewhat helpful in the real world. It is a good starter course for those with little to no prior Java experience as well.
This was the first course I took in the OMSCS program and I chose it because at this point I had 2 years of professional experience as an iOS developer, and figured it could be a nice introduction into the program.
Course Content:
The course went through many topics like UML, OCL, state transition tables, design patterns, etc. I think it was a relatively good overview to give you some familiarity with the kinds of things that are out there. The projects focused heavily on UML and Object-Oriented programming in Java.
Course Content Delivery:
The content was delivered in the form of 1 to 2 minute videos by the lecturer. They were a bit of a slog to get through, and I felt that creating a transcript would have been a more efficient method of getting information across.
Overall Thoughts:
This was definitely an easy class that did not take much time commitment. If you have a reasonable amount of experience in the software development field, I believe you will have an easy time of it. At the end of the day, what you get out of a course is what you put into it, and unfortunately I did not put as much into it as I would have liked. Perhaps this was exacerbated by the fact that the quizzes following each set of lecture videos could be taken multiple times, and that there were no exams. So the projects really only tested a subset of the course content.
I also felt that it was too heavily focused on UML and Object-Oriented code. Firstly, I don’t know anywhere that still uses UML - and the way we were expected to use UML in some of the projects (updating the UML as we went) showed me why. I understand using UML for up-front design and thinking through the architecture, but I can’t imagine anyone still would want to update as they went - it gets out of date fast and very easily. As far as object-orientation, I use a functional approach at work and so wasn’t very interested in learning OOP patterns, but maybe that’s just me (and maybe I’m wrong in doing this).
My dislike rating is more about not being as excited about the course content as I thought I would be. If you’re interested in modern software architecture principles, I think you could do better than OOP / “Clean Code” / SOLID, etc.
If you are just looking for an easy A, and don’t mind a group project, then this could be for you. Instructor and TA’s are all great, but the video lectures are not helpful at all (with one or two exceptions). What could be the most interesting and useful information is crowded into the last few lectures with a quick mention and no testing or projects. No grade or feedback was provided for the final group project which is unacceptable.
An easy class in the sense of grading and programming, but a relatively frustrating class in the project requirements. There are no exams, only quizzes, which are very easy given the reading material.
Dr Moss is nice and fairly helpful in the office hours. He also cleared up some of the ambiguity in the project requirements between office hours and piazza, so make sure you are trawling those as needed. One TA was fairly rude across all communication channels, but the rest were fine.
As a Hardware Engineer by trade, with an intermediate programming background, even I didn’t learn much from this class. Definitely an easy A if you just put in the work (5 hours a week averaged over the semester), though be prepared to just “do your best” with the UML. Additionally, the lectures are the worst I’ve seen so far, though this is my third class and apparently the other two I’ve taken set the bar fairly high.
Overall I’d recommend it as an easy A but slightly frustrating. Also you MIGHT learn some better design/architecture practices if you force yourself to use them, though you likely already employ this if you are a software engineer.
This course was easy. As already mentioned in previous reviews, it relies heavily in UML, but I don’t agree with that being wrong. UML gives a good framework and best practices to build upon.
My biggest gripe with the course was really with the video lectures. They are not as well produced as others like HCI or SDP, in the sense that they are very short, they don’t have include a hand or a pointer to what is being presented in the video to better reference what is being talked about, content disappears while you want to still look at it, and the inclusion of a “student” to make the videos more dynamic just turns into a waste of time. But more than that, the lectures are not very much related to the assignments and projects of the class, and it’s like the lectures are going one way but Prof. Moss and the TAs are going another way. Most of the content of the lectures isn’t even addressed or useful for the assignments, just the first two or three sections were relevant. I stopped watching after that because I didn’t even feel like the content was going to be useful to me.
The projects were the right amount of challenging and as long as you can do Java programming you’ll be good. For the group project, I was glad that they were more flexible, and we could even choose another language or stack to work with (we did a Springboot backend in AWS along with an iOS app as frontend).
As a whole, it was a good introduction/deep dive on UML, and good practice for creating software projects from scratch, but I didn’t learn much more than what I didn’t already know, being a software engineer for 5 years.
I’d also have expected the course to also go into modern architectural topics, such as Clean Code and SOLID principles.
This was my 8th course in the program and I took this class as an easy A to pair with another class.
Overview: Well structured course about software architecture and general design principles of software systems.
Assignments: 7 total including one group project and group review. The indivudal assignments are very straight forward and take anywhere from 30 minutes to a few hours (for the initial project implementation - ~5-10 hours with strong java skills). The group project is a lot more substantial but can be done in ~20 hours assuming you start from a good code base (you pick one members individual project and work from there) and have a solid plan for how to implement new features. The biggest part that added time to the group project was actually working with other people. A single person could do all the work in half the time of the group but that’s not how it works in the real world.
Quizzes: Based on the lectures and reading. Very easy, no trick questions. You should probably do the reading before taking the quiz but its not always necessary.
Lectures: Well structured and informative. Honestly only watched a few of them but they seemed good.
Exams: None!
Overall: You can get a lot out of this class if you’ve never worked in the industry. If you have, you will be bored. There is a TON of overlap with CS 6300 (software development process). You can easily get an A with no more than an hour or two per week but every so often you will be in the 10-20 hr range depending on your familiarity with java and how good your group is. Personally, I took this course as an easy A to pair with something else because I’m kind of burnt out after 2 semesters doubling up + summers. I don’t feel like I really got anything out of the class that I didn’t from CS6300, but I could have.
This is my first course in OMSCS.
Assignments:
A1.CatMe, ~10 minutes
A2.UML class diagram, ~3 hrs
A3.Peer review (for A2): ~2 hrs
A4.Implementation (Solo) for the project: ~10 hrs
A5.Group plan for project enhancement (Group Work): ~2 hrs
A6.Group implementation (for A5): ~ 20 hrs
A7. Peer review (for A5 and A6): ~ 30 minutes
The workload overall is ~10 hrs/week for this course. It is perfect for the first course and I would highly recommend. Secondly, TA are super nice and responsive in Piazza. Office hour helps a lot for assignments. I would say this is a easy A course for everyone. Before taking OMSCS, I have no experience and knowledge about Java and OOP, but it doesn’t stop me for finishing all the assignments.
Advantage:
1.Easy A / perfect match the 2nd course in the same semester.
2.Learning solid OOP, Java basic and Spring Boot
Disadvantage:
1.lecture video aren’t interesting
2.Don’t expected too much learning about Java.
One of the more enjoyable courses in my journey.
This class has gotten a lot of positive and negative reviews over the years. Professor Moss is doing a great job with it right now.
There are six assignments.
- A background survey
- UML Diagram
- Peer Review of the UML diagram
- Implementation of the program
- Group project enhancement write up
- Group Project delivery
There are six quizzes. Lowest is dropped. Two attempts per. Mostly true/false.
I put 6 hrs week workload. It was less than that for A1,2,3,5, but significantly more for A4 and A6. You can’t really work ahead, but this would pair great with a class that you can work ahead in.
The enjoyment in this class comes from the fact that there are so many ways to do things right in software design. (There are also a lot of ways to do it wrong.) You work on one project the whole way through, getting a six page list of requirements to start. You create a UML diagram outlining this project, then peer review three other students in the second assignment. I had two meaningful sets of feedback and one kid who either didn’t know what was going on or didn’t care. The individual implementation was more of a refactoring exercise. The staff presented us with a monolithic version of the program that we had to re-engineer into an object oriented program in java. If you don’t know Java, there is plenty of time in the first couple of weeks to brush up. Plus, they hand you a working version of the program, you just have to move things around and make it OOP.
There are a lot of complainers about too much UML. These people are missing the point. In software design, you have to document your system in much detail. There are several ways to do this. This course focuses on UML because the resources are readily available and it makes grading uniform and consistent.
Word to the wise: find your group early in the semester. Other people who are go-getters will be doing the same. I had a great group of three and everyone contributed and even finished early.
The final assignment was the bulk of the time spent in the semester. We implemented a database, gui and security. It did take a strong effort to get it all working together and working right, but we had the people to do it.
TL;DR I remember a fella named Chuck Cottril on Google Plus who said this class was YAGNI (you aint gonna need it.) While you don’t need it, it was a great exercise in java, teamwork, and software design. The new skills I learned were what we implemented in the group project, so choose your enhancements on what you want to learn.
As all the other reviews mention the class focuses way to much on UML and the rules of the language which is never enforced or focused on in a professional setting. I think UML is a good guideline of making diagrams for a business setting but the strict rules are useless and shouldn’t be a focus.
I would have preferred more focus on design patterns and things like studies into monolith structure to micro services and things of this nature, but none of this is ever addressed really. If you need an easy A then make sure to choose your group for the final project wisely and put in a decent effort.
The TAs are pretty good and responsive, especially for the final project. I’m not sure if it was just the summer but we didn’t know half of our grades until the class was over which I’m sure could cause problems for some.
For some background I started as a CS undergrad and finished CIS, and I took a course similar to this there. I already had knowledge of UML and so this class was mostly useless for me, but if you have no experience in UML then it’s a nice thing to know. It does require Java programming which I have almost no experience in, but you can google your way through that if you have any programming experience at all really.
This was a very easy class. I have experience in the software industry at both the enterprise and startup levels. I never used Java, but that was only really a minor inconvenience. Otherwise, super simple class that focuses way to much on UML.
Overall this class is rather easy. I wouldn’t say very easy only because of the amount of tedious UML creation involved. I was hoping it would have more substance around how to actually apply various software design patterns; it did not. I was also hoping it would cover how to not only design from a “green field” state, but also how to approach applying modern design to legacy code. It did not. There wasn’t much substance to this course, just plenty of diagrams to draw. You do need to be able to actually write Java code to complete the project(s). In addition getting a good team together for the final project is important for success. The one positive I can say about the class is that I found the TA’s very active on Slack and Piazza. They were pretty helpful overall and did want students to succeed.
As others have said, this is an easy A with little instruction. Focuses waaaayyy too much on useless UML which is disappointing because there are a lot of really great concepts that could have been covered that will actually help you in your career. Lectures touch briefly on Object Oriented Design Patterns and fundamental concepts like coupling and cohesion and avoiding monolithic structures. All good but basic concepts that are 20+ years old. I was expecting a lot more from a graduate level course on Software Architecture from a top ten CS program like GaTech.
You get what you put in, but it is an easy A even if you don’t put in too much. The projects can be fun if you approach them that way. There is a major noticeable gap between experienced students and those without any professional software engineering experience so you’ll probably learn more from other students than you will from the course itself if you are active and engaged.
The projects are simpler than 6300, so if you are new to Java this is a more fundamental choice. I found the assignment of editing existing code into classes is helpful. A lot of grade on drawing diagram and reviewing other people’s work, so even if I took 6300 when I know nothing about programming I received much higher grade in 6300 than this one. Lectures are dull, however the latter part of lectures are fun to my surprise.
This is a really good class for me (as a non CS undergrad). It gave a lot of good information, decent amount of reading, and fairly straight forward lab. Not my favorite class, but not my least favorite class. Labs are in Java.
First course in the program, I have no software architecture experience before yet spent minimal effort to get an A in this course. This course is definitely not a graduate level course. The course is a huge waste of time and probably could be done just reading some posts on the internet. Take it if you want an easy A (but learn almost nothing), otherwise stay away
I took this as an easy class to pair with RL (going for the ML spec). Besides the final project implementation, this class is a joke and as such pretty boring and useless.
I just quickly clicked on all the lectures, did every assignment in <1hr, and got an A.
I did have a badass group for the final project though which matters a ton. I was the only one who knew front end, so I did all the visuals (ReactJS + Bootstrap). A good group is a must for an A, so find people asap.
As someone else mentioned, this class should not exist. SDP-6300 is a much better course in every sense of the word. This class focused far too much on UML throughout the entire semester. It was a giant waste of time but an easy A. If you want to learn about UML documentation or take a light class to get you closer to graduation, take this. If you want to learn something useful, STAY AWAY!!!!
This course should not exist. It was a waste of time, but it gets me one class closer to graduation. Take the final project seriously and impress the importance of professionalism on your teammates to get it done quickly.
Probably one of the easiest courses in OMSCS. I have no rigorous software engineering experience and don’t come from a CS background yet managed to get an easy A.
Take this course only if you are burnt out or paring with another heavier course
This a well structured course and very easy as well to get an A if you have a background of software development. No exam but a group project in the end. The quizzes are open book and pretty easy. The course focuses on UML, different architectural styles, design patterns which I found useful and I can apply this at my work place. If you submit all the assignment and quizzes on time, be sure to get an A.
This is my first course in OMSCS. I think it focused too much on UML. Course content is not very useful. The only time consuming part is final project, which takes several evenings. Easy to get A.
General
- Skip this class if you have any software engineering experience. You won’t learn much.
- Take this class if you are looking for an easy A.
- Great teaching team and well structured class!
- Professor Moss is very involved in office hours and personally responds to many Piazza posts.
- TAs are responsive on Piazza.
- No active slack group.
- There is a group project in this course (last 4 weeks of the class). You can pick your own team so going into the class with a team helps. Having someone with front end experience helps as the group project has a backend and front end (GUI/webpage/mobile app) component.
- Assignment instructions were very detailed and easy to understand. Very few clarifying questions required.
- The bulk of the coursework is with the group project (last ~4-5 weeks of the course). The rest of the semester is pretty light with assignments taking ~5-10 hours each) and quizzes taking ~1 hour per attempt (open book).
- No exams!!!!
Quizzes
- 6 quizzes, open book. Based on obscure knowledge from readings/papers. Open book, 4 attempts.
- 2 CATME surveys - First one is for team formation (~15 min to fill out) and second one is for team member assessment (~30 min to fill out). Make sure to leave detailed comments about each team members contribution.
Assignments
- Assignment 1: CATME survey
- Assignment 2: Course project design - The whole class is based on a designing a system. When I took it, the project was to design a star search simulation system. Create UML diagram and sequence diagram for A2. Time Required: ~10 hours. This is not difficult but it does take some time to read the instructions and come up with a good design.
- Assignment 3: Peer review - Review 3 students’s designs and diagrams and leave feedback based on specific format specified in the instructions. Time Required: ~8 hours. This is not difficult but it does take some time to review other diagrams and provide useful feedback.
- Assignment 4: Initial implementation of the system: Java coding, starter code given. Have to change this from monolithic to OOP design. Time Required: ~10 hours. Assignment instructions state all the requirements. 10 test cases given, TAs will test with about 20 more. You aren’t graded on the efficiency of your search algorithm though so a basic brute force ish algorithm is good enough.
- Assignment 5: Group Project Improvements; Write up a proposal with 3 system improvements. Time Required: ~5 hours (most of which will go into discussing and detailing improvements with your teammates).
- Assignment 6: Simulation Coding - Add 3 improvements on top of A4 code. Usually groups will just pick one team members code to go off. GUI was required in the past but was not required this term so it counted as one improvement. Sample improvements: Data persistence, rewind/forward actions, adding other objects in the search region, search region object fueling/fuel capacity. Time Required: ~30 hours (+/- depending on how well your group works together). We used github issues to track bugs and assign tasks.
Contrary to most of the reviews here, I enjoy every bit that this course has to offer. I think the class is well designed to teach Objected Oriented Design and software architecture concepts. The class seems well-staffed with TAs this semester, with both the Prof and TAs working hard to ensure the class can continue despite difficult circumstances. Moreover, they are very active on Piazza and are patient with students’ questions.
The course materials teaches software engineering and architectural concepts that are relevant til today. The textbook teaches Object Oriented Design through UML, design pattern applications, and is written by Craig Larman, a computer scientist who contributed much to the computer science and agile community.
The material was also supplemented with interesting readings on clean code, and design patterns such as the GoF. The Prof also makes a point to hold reading discussions to discuss the topics at length.
The assignment is also designed to apply what you have learned. I think the assignment instructions could have been clearer to minimize repeated questions on the forums though.
Another software class similiar to CS6300. If you come from a CS or Software background this course would be a free A for you.
Therefore, don’t take it if you are working as a software engineer. You will be bored because this course teaches you nothing new.
CS 6310 is a great class to take as your intro class to the program. Do not take CS 6340 as your first class - you will regret it.
Very easy A class. Too much focus on UML. Final group project is the biggest workload, make sure to form a good group.
Dull subject - almost similar to CS-6300. I would say this was not organized to an extent. Piazza posts would take ages for a TA to respond to. Project and course videos was dull as well. I would say to take this course only if you require an ‘A’ for your grades.
The course content was pretty meh, make sure you pick your group for the final project.
The course is comprised of the following:
- 8 Assignments
- 2 - 7 focus and build iteratively on the lawn mower simulation, culminating in the group project to implement a GUI
- 1 and 8 are CATME surveys
- 6 Quizzes
- Participation
Assignments
1: Catme Survey
2: Initial mower design - UML diagrams and Q/A
3: Initial mower implementation - Coding
4: Mower modifications - UML diagrams and Q/A
5: Peer reviews of Assignment 4
6: Software architecture paper
7: Group mower implementation - Coding
8: Catme Survey
As seen above, there is a stark lack of programming in this course. It largely consists of reading dated literature and writing-based assignments. The first coding assignment wasn’t until 6 weeks into the course, and the final was due nine weeks later – that’s all the code you’ll write in this class.
Quizzes
There are 6 quizzes in the course, and they almost exclusively focus on Larman’s Applying UML and Patterns book. This book was originally published in 1997, and it has not aged well. How someone managed to write 600 pages on UML practices and specification without losing their mind is astonishing.
I was able to take each multiple-choice quiz without any preparation or studying, by simply ctrl+f‘ing through the PDF while I took the quiz. You have 4 tries for each quiz, but you get no intermediate score or indication if you missed anything or got anything right. Ultimately, I retook each quiz and just switched answers for questions I wasn’t able to find verbatim in the PDF.
I would avoid using O’Reilly all together as their search function does not work well. You’re better off finding the PDFs. Again, you’ll occasionally need to read another paper, but I think each quiz had some non-trivial amount of questions from the Larman book.
Final Project
The group project is just another iteration of the mower simulation with some changed requirements. We all took the Catme survey at the start of the course, but group creation is a complete free-for-all. Either you have some buddies to group with, or you’re choosing/joining groups at complete random. This led to a group with disparagingly wide range of skills and motivations. Unless you get really lucky, you’ll likely end up doing the final in Java and some sort of GUI on top of that (Swing). You’re limited by needing to package the final on a Linux VM, and the common denominator language of having done a lot of pre-work in Java in Assignment 3.
You’re technically allowed to do anything within the VM (web-based, etc.), but, again, this depends on your group competencies and motivation.
This was ultimately a really poor experience in sloppily copying and pasting code from individual’s assignments.
Udacity
The videos associated with this course are honestly embarrassing. They’re extremely outdated, the quizzes are broken and non-engaging, and the production quality is really poor compared to some other courses.
Overall
This course was a huge disappointment. I got an A in the class, and I never did more work than a couple hours the day before an assignment was due. The final project took some coordination, but you’re working with other remote students – your luck will be hit or miss here. In retrospect, I’m truly shocked that this is a Master’s-level course. I was expecting a deep-dive into hands-on design patterns and larger architectural implementations in various languages, cloud-based workflows and distributed design. Instead, you’ll simply read dated books on UML specifications and horribly dated opinions on what it means to be a Software Architect.
Honestly, skim through one of the required readings and Google each “expert’s” name. Most of the people featured in this book can’t even submit a proper, clear headshot of themselves, much less provide any meaningful opinion on software architecture – this is just full of self-stroking egos.
I suggest taking this course as an easy A and double it with something else to get ahead in the program.
That was my first course in the program. Wasn’t a bad course if you follow the lectures weekly and follow the discussion. After seeing other classes by far this class was my favorite. Most things were clear and easy to follow.
To start off this is a fantastic course. Great structure! You have two tracks. Hands-on work track and Reading/Quiz track. Assignments include
- Catme survey - Yes there is a weightage given. So please take this survey
- Initial analysis and design of the system
- Individual implementation of the system - skeletal monolith code is given. Make it more modular and add some algorithm. Algorithm effectiveness carries a good weightage
- Update the design based on new requirements and changes to design while coding
- Do a peer review of the design
- Do a group project with new requirements added
- Do one more catme survey
The design of this is based on how software evolves in real world, with new requirements coming in all the time.
There are 6 quizzes and best 5 out of 6 quizzes will be taken. Each have 4 attempts. Highly recommend reading the required readings and attending the office hours (or watching recordings) and getting clarity on the questions. There is a wealth of information in those sessions
There is one position paper to be written based on the book 97 things every architect should know. You get what you put in. There is a lot to gain from this course if you are ready to engage.
Only negative I see is with the time taken for grades to be turned around. At the course withdrawl date, there was about 35% of the grades turned around. It becomes a guesstimate to drop at that point. At the course end date, and the official grade submission deadline, about 60% of the individual grades were returned. 40% - group project, position paper and participation grades were not returned till the letter grade submission deadline. Students got their letter grades prior to the individual marks.
Grading in this course is very very fair and thorough. So this is really understandable that instructors take a little longer to finish grading. Lot of posts on piazza at the end of the course was about the grades not being there in place.
This is something that they should improve in the next term.
This was an interesting, if dry, class. The quizzes focus on reading from different books (primarily Larman’s book Applying UML and Patterns) and answering questions in an open-book format. Lectures are of varying quality and I found myself drifting off. About halfway through I stopped watching the lectures and just focused on the readings.
The assignments were more interesting. They involved creating documentation and implementing a Java app for a toy problem (search on youtube for some examples of previous semesters projects). One of my favorite assignments was writing a response papers to two articles from a book on software architecture problems.
The group project is re-doing the individual assignment with some added requirements and complexity (primarily adding a GUI front-end, either through a browser or using Swing/FX). This will vary depending on your group but isn’t too hard especially if you did well on the individual project(and my group was excellent)
Overall this is a great class to take if you are interested in software engineering. Some of the topics may be dry but thinking through and critiquing designs will help improve your design skills. You will learn more UML than you need to but have a better idea of design-related challenges when writing software.
The class wasn’t too difficult, but the topics felt a bit bland. It felt more like a reading course than programming course. There was a lot of material/topics to read through, and you had to take quizzes on them. The quizzes are open-book, though, so fortunately, you don’t have to memorize hundreds of pages every week. It’s on a similar realm to the SDP course in that it touches on design diagrams, the programming projects are in Java, and there’s a final group project. I did not like this course as much as I did SDP, though. The lectures and readings went really deep into design in software architecture, and they felt a bit disjointed from each other. The course isn’t hard but does require a non-trivial amount of time and dedication to complete the lectures, reading, quizzes, and assignments.
While I don’t particularly enjoy group projects, I think the group project is structured a bit better for this course than SDP. Most of the work for the group project is already completed in previous individual assignments, so for the group project, you’d be smart to just build on what you already had. For SDP, the group project was almost from scratch, so there was a lot of work to do.
Overall, the main way to be successful in this course is to stay on top of the work every week and keep a good schedule.
There were a few downsides to the course. Firstly, due to the sheer size of the class and the nature of the assignments (conceptual, as opposed to pure programming), the teaching staff had a really hard time keeping up with the grading. By the time grades were due for the semester, we were still missing grades from 3 (out of 8) of the assignments. Secondly, grading feels quite… subjective. I had a fantastic group that was goal-oriented and talented. We combed through the requirements with a fine-toothed comb and made sure we checked everything off. We had points deducted for parts of the assignment that did not have concrete specifications—the reason being that it wasn’t “enough”, and that things could’ve been “better.” Overall, the final project grade was really excellent and our team members received A’s for the class (i.e. there was no point in asking for a regrade), but it was a bit frustrating to see points taken off for seemingly subjective reasons. I personally did not feel like the structure of the class really offered ways to effectively enhance students’ understanding of the material. Particularly, I didn’t really feel like I became a better software architect as a result of this course. All in all, I would say that if you’re looking for a relatively “easy” class to get an A and to tick off a foundational course, this is one of those.
It was a good first-class. Be careful taking it though, if you haven’t decided on a track yet.
I would recommend this course to anybody. It was informative and brings value. I didn’t have tests.
I did not like this class. It was more a class on how to write UML which I have never seen used in a company setting ever other than very basic uses. So the lectures feel a little outdated. Additionally, the lecturer, who is now retired I believe so they have others running the class now, is very dry and not fun to watch. He has a student with him in many lectures that he asks questions to but he is always correcting the kid and making him look stupid. I just felt bad for the kid most of the time and felt like the lecturer was being overly critical.
The group assignment was unpleasant, especially because only half of us really wanted to get the assignment done well and on time. Two of us stayed up until 3 AM pulling it together because other people dropped the ball. The assignment was interesting enough, but the design of the code we were given was really strange and hard to work with. You’d think a class about good architecture would try to be a good example and give you a solid code base to work with…
Overall I disliked it. The assignments were incredibly tedious and mostly about doing UML graphs, not in coming up with good designs. I took 6300 which is very similar and I felt like I learned most of the same stuff (sans UML, thank goodness) and with a way better lecturer. I recommend you take that class instead.
Thankfully I did learn about TDD for the last assignment and that I did use later.
After having taken SDP and this course, I would take SDP and skip this. This course covers OOA in depth. SDP touched on the entire development process which is useful anywhere but many environments would never delve into UML like you do in this course. You will spend a lot of time creating and reviewing UML documents. The main project was interesting but too much time was spent covering the semantics of the project and not on the material the of the course. Agile development was a topic but was not covered as well as I expected I think because of the focus on project requirements. It’s a useful course that may be good for you to organize and document your concepts, but its not my favorite.
I feel that this course is just too easy. But probably a very good choice as the first course.
This was a terrible course with antiquated and useless material being taught. Hardly the stuff of an MSc program. I more or less skipped watching any of the videos, which presented mind-numblingly useless details from outdated textbooks or concepts that have largely been superseded by newer techniques/methodologies for coordinating technical design & architecture.
The tests were super-easy, as were the assignments. If you’ve done any coding or architecture in your life (i.e. you’ve written code for more than 2 years), you should totally skip this course and get your money’s & time’s worth elsewhere. GATech, you need to replace this course.
I find it interesting how a lot of people are giving this course < 10 hours. I can see that happening if you get on a group project where the workload is spread evenly or your teammates do most of the work. Unfortunately, the group project I was on had a lot of lazy classmates. I ended up doing most of the work for the project. The last 4/10 weeks of the class were absolutely draining with the group project. Choose your teammates wisely.
Software Architecture and Design consists of 6 open book quizzes and 6 assignments.
The quizzes cover the following topics: Honor Code, Plagiarism and Collaboration Awareness, Software Engineering Body of Knowledge Software Design, Unified Modeling Language (UML), Architectural Styles and Models, Design Patterns and Related Issues and Software Design Principles.
The assignments are the core of the course. Currently, this course uses an object oriented coding project (a simulation for mowing grass using multiple lawnmower robots) which is used throughout with additions/updates as the term progresses.
- Initial Analysis and Design: Read the problem prompt and submit a UML diagram and description of how to solve it.
- Individual Implementation: Use Java to code a solution. Monolithic starter code is given, but the solution should be object oriented.
- Design Updates/Modification: Additional specifications for the project are given. More documentation is required including a class diagram, sequence diagram and description.
- Design Peer Review: Submit an analysis of the work of 3 students from the prior assignment. Comments should connect directly to topics discussed in class.
- Architecture and Design Position Paper: Write responses to a few opinion articles about the role of software architects.
- Group Project: Choose a group and implement the final version of the problem. Requires source code/VM, GUI, 4 diagrams and a 10 minute video demonstration.
Office Hours, Reading Reviews, Udacity Videos, Piazza round out the learning experience. Overall, this class is well organized, but you can decide on the amount of effort you put in since many aspects of the course (readings/videos/office hours) are essentially optional as tests are not given.
You have to make a lot of UML diagrams, which is terribly boring and tedious - mostly from creating the diagrams manually with generic WYSIWYG charting tools. The actual process of planning out the complex architectures are interesting and useful, but the group project makes it difficult to see something of your own come to fruition. Once the group project starts, the class becomes more of a practical course on what it’s like to work on a software project with a team and a deadline. The experience was very much valuable and appreciated, but I was disappointed how the core architecture/design content sort of fell to the wayside over the final month.
Literally nothing useful, but lots of meaningless work. The assignments requirements are quite vague. The grades heavily depend on how much does the ta like your work.
Generally, it is OK. Overall, Software Architecture and Design is worthwhile if you’re interested in the topic. It’s not very programming-heavy but requires a non-trivial amount of work on a weekly basis. Think carefully if you’re planning to combine this class with a “harder” class as the amount of work needed can be deceiving; especially during the group project phase.
I started my OMSCS with this course. It is a course which has a decent amount of content to offer. This is not a 100% programming course. I would put it as more of a requirement gathering and designing course. I feel that this course could get you a perfect start into the program if you are one who prefers a comfortable start. I am working as a full-time software engineer and I believe that it contributed to an extent. The following are the PRO’s and CON’s as per me:-
Course Structure:- 1) 8 Assignments 2) 6 Quizzes
PRO’s:- 1) The Course Instructor is really approachable and he takes the best effort to address all questions from students. 2) In-detail content on UML diagram’s 3) Approachable TA’s and quick replies on Piazza
CON’s:- 1) Grading is slow and there was some serious percentage of assignments left before the withdrawal deadline.
1 individual project, 1 group project. Several UML diagrams, and paper reviews. 6 open book tests.
Pros: The projects are interesting. Even if you are an experienced programmer, the projects will make you think. There is also a group project. For those of you who haven’t worked together with other folks you don’t know, this is a learning experience. People admitted to OMSCS program are generally very smart, so once I worked out the communication barriers, it went smoothly. Grading is on the generous side as long as you are following instructions and keeping to the point. Even though I went in thinking why I needed to learn UML, I ended up learning about software design patterns (things you don’t do at work). Therefore I personally think it added some value in the end. Cons: The lectures are extremely boring and the material needs update. There are way too many lectures, can be condensed and too much emphasis on OCL/UML. There could have been a better focus on design patterns, case studies of famous software projects, etc.
This course will teach object oriented analysis and implementation with UML, and have several projects(1 group project) and 5 quizs. There are lots of class video to watch. The projects are all about design/impl some Mower system, and Java is heavily used. If you have lots of experience in software engineering, this course will be an excellent choice. If you have few instead, you might not quite understand the course.
Very easy class.
Online lectures that you can just skip through and participation quizzes retake as many times as you want.
A couple projects for software design, a software implementation project, real open note quizzes that you can retake 4 times, a 5 page paper, and a group design/implementation project at the end.
If you turn everything in with any amount of confidence in your work, you will get an A.
Spring 2019
Took this class immediately after taking CS 6300 (Software Development Process). This class can be seeing as a “spiritual” successor to CS 6300. SDP’s focus is on the implementation/test phase and SAD focuses on the requirement and design aspect. It’s worth taking if you have interest in software architecture.
Structure
- 1 individual programming assignment.
- Multiple design/uml assignments.
- Peer-reviewed assignment.
- 1 Group project that builds upon the previous assignments.
- 6 quizzes (lowest grade is dropped).
- Class participation (group teammates feedback, Udacity quizzes).
Pros
- Goes pretty in depth into the different UML diagrams.
- Individual and group assignments are interesting.
- If you are lucky to have a good team, the experience can be very enriching.
- Most fellow students are knowledgeable and have plenty of professional experience.
- TAs are quick to reply and involved in Piazza.
Cons
- Assignment grades are returned very slowly. We all had about 40% of our grade TBD up until the grade submission deadline.
- Groups are formed “organically” which means any one can attempt to join a team (this can be seen as a positive too). This seems to work okay for highly motivated students as they all come together in the beginning but also tends to leave the procrastinators clustered together. Advice for the group project: Start talking to potential group mates from the start of the class.
- Not very heavy into programming until you get to the group project (could also be seen as a positive by some people). Most other assignments are all UML designs and/or essays.
- Mismatch between the assignments and the Udacity videos. Those videos need to be updated.
Overall, Software Architecture and Design is worthwhile if you’re interested in the topic. It’s not very programming-heavy but requires a non-trivial amount of work on a weekly basis. Think carefully if you’re planning to combine this class with a “harder” class as the amount of work needed can be deceiving; especially during the group project phase.
Liked it.
This is a great class, if this is your only class you will have fun and do very well. do NOT pair this with a harder class, you will rob yourself of a great experience as you will neglect this class and both grades will suffer. no tests, group project is actually fun (but I may have gotten lucky with a solid team).
spring 2019
- grade slow, regrade slow.
- They don’t give you regrade result before withdraw ddl.
- You score depends on your luck about which TA is assigned to you. One of my HW got extremely low score <50%. I listed all the reasons for regrading. Two weeks passed, the TA and instructor chose not to give even an simple reply.
- requiremens of assignment are never clear in the instruction. Without attending office hour or looking through many question posts about requirement in piazza, it’s impossible to get a high score. I got almost 95% in all other assignments/quizs, including the code implementation. However, the mean TA used some subjective questions to deduct your score. You did it！ I withdrew 6310 and even start thinking whether I should quit OMSCS. I rather spend my time on writing more LC than wasting my time on such course and mean people.
This course progresses slow. TA grades extremely slow - before withdraw deadline, only 2 assignments had been graded (Notice the total number of projects is about 8). Instructor never responded my query. All he cares is just office hour, but individual’s questions are under attention. Assignment of grading for TA is by students’ last name and your regrading is by the same TA, who will be responsible for ALL YOUR ASSIGNMENTS. Your fate is highly ruled by luck (TAs’ mood), since several assignments are short answers and depending on TA’s subjective judgement. If you are not lucky enough, you will be wasting your money feeding those who give you unreasonable low score, want you to withdraw and retake, with little respect of student’s hard work, appealing, and asking for help. “Regrading” doesn’t work at all for such TA. My program passed all the tests, but for the writing part reasoning about my design I got < 60%. Can you believe this is not deliberate at all? He may add 1 point to fool you looking to your regrade, which is SICK. I don’t know how OMSCS can hire this kind of person. You can not complain about this, otherwise your TA may treat you harder. It is horrible. You will feel being cheated of money here. And yet they feel you didn’t pay enough, so it is none of their business to treat you fairly.
This one I decided to withdraw as I just didn’t see any value in taking it. The first assignment was only to have a class diagram of the idea presented on the assignment and assignment 2 to implement it in java. By that time I realized they had nothing to offer.
Waste of time, do it for the the credits or save yourself the money .
The prof and TA were very active in Piazza. I think my TA’s grading was pretty generous but it was too slow compared to other courses.
Udacity lectures are not necessary for completing assignments but you need it for little participation grade.
You must watch the weekly office hour videos for your assignments since the description is often unclear. They usually have to answer a lot of questions.
You must know Java for programming assignment and group assignment. Front-end skill is required so make sure you learn it or get in a group that has a member with front-end experience.
Honestly, you are not going to learn a lot from this course if you already have taken CS 6300 or undergrad software engineering course but you will get an A guaranteed.
There is a great opportunity to use Java in designing an object-oriented system such as “Mass Transit System” for both individual and group project. Depending on the group, you may also learn different front-end design techniques(Java Swing, Fx, etc.) to display the output.
Pros:
- Fairly easy course
- No test
- 1% or 2% Extra Credit, if 70% or 85% students complete CIOS review. We received 1% Extra Credit as 76% of students completed the survey. There was also an additional 0.5% Extra Credit for Individual coding project(Assignment-5) as there were additional test scenarios by mistake.
- 1 individual coding assignment
- 1 group project including both coding and UML diagrams
Cons:
- There is not much correlation between assignments and lectures after UML
- Most of the assignments will be graded by one grader. If you are unlucky you may end up with one who does not pay attention to grading requirements such as essay length or provide feedback too late.
- Only 2/10 assignments are coding related. Other assignments(70% of the grade) are UML diagrams, essays or feedbacks.
- UML diagrams are heavily graded.
- There were conflicting instructions as of when an assignment is due. One Instructor Piazza post said assignment 5 and 6 were due on the same day, though Canvas had different dates. The Piazza post was never updated. Students only need to follow Canvas due dates and announcements as it will supersede any Piazza/Office hour posts.
- Office hours are great but can be lengthy and confusing. As a result, there are ~100 posts/updates just to clarify the “rewind” feature of the “Mass Transit System”
- There are only 3 weeks for the group project which includes knowing your group members, analyzing each other’s projects(5 and 6) to be used as the basis for the group project and deliver the final project, video presentation and working VM(Virtual Machine). This is especially difficult in Fall as members may be unavailable during Thanksgiving.
- If you’re unlucky, you may end up with group members who do not care to contribute or communicate and think they have already contributed by doing previous projects! You could easily see your time spent per week rise dramatically (~40hr/week) in the 1-2 weeks before the project deadline.
- 50% of the grades (Assignment 7-10) were not released until 2-3 days before the official grades were due.
- Just choosing a group member based on location is not a great way to form a group. For group-project, make sure you have someone with FrontEnd experience.
Also, remember to submit all files for an assignment every time. There were many students who only submitted all required files the first time, but then only resubmitted an updated file and not the other one. For instance, if you have 2 files to submit, resubmit both every time even if only one of them is updated. As a result, Canvas only had some of the required files.
Though it is an easier course, it may take more time than you think.
Class moved at a snails pace. Moves so slow you might forget you are taking it if you are not interested in the reading discussion. Most weeks I put 0 hours into this course, but on the rare occasion there is a project, I put a decent amount of time in.
No tests in the course, so if you have some knowledge of the material, the lectures are not necessary to watch, and they are much longer than other course lectures, but they are very thorough.
Be prepared to have time to work on the group project. Everything moves slowly throughout the semester, but then you have about 2 weeks at the end to collaborate with your group on the final project (made worse by thanksgiving holiday in the fall).
Easy class if you have a background in Java. Good class to pair with a more difficult one. Wouldn’t recommend as a first course due to it being poorly run IMO.
- Great to consolidate existing Software Architecture and Design knowledge.
- Included several papers which give a full understanding of Software Architecture and Design across several years. * Does not cover latest technologies in the industry as well as new architectural patterns. The assignments does not encourage their usage or implementation. All programming assignments are done in Java.
- Helps to understand how to balance between high-level and low-level software design.
I really am struggling to write a review for this course. I think CS 6310 is more of an extension to CS 6300. I found the course rather boring, with endless amounts of (frankly useless) theory in the Udacity videos. Other than the group assignment, the class only has one real programming assignment (assignment #5), which wasn’t that bad. I found that Professor Moss was a good instructor, but his assignments really had nothing to do with the Udacity lectures. Frankly, I din’t know what I learned in this class, but it reaffirms the potential power of UML.
If you have the time, I’d take this class, but don’t expect to learn much.
The good part of this course, it tells you the basic concept of UML and software design process. It’s good to take it if you don’t have any idea of software design. However, the content is shallow and not worth to take it if you already know these concepts.
Video content: I will say not helpful for the assignments and project at all.
Assignments: Some of the assignments are just funny, like discuss some statements from a book. While the design and individual implementation of the final project earn some credits for this course. Not hard but feels like you did a software product from scratch.
It is an easy course if you are a software developer. Assignments and Video lectures do not match. I got a good understanding of Design from this course. It would be a good course to take alongside a difficult course.
This course teaches useful UML and design patterns. Although if you’ve taken 6300, you probably won’t learn much here (especially, as there are no tests, you don’t even need to watch all the course material)
The course material is not hard, the management somehow makes the course very hard.
For example, in the major individual coding assignment, the advisor noticed there are errors (more like inconsistency, the VM uses one printout format, the PDF uses another) in the examples one month before the deadline, this is what they did to notify the students
-
replied in a piazza post, which is either pinned or highlighted and by the time it’s approaching the deadline (approximately a month from the post), it is already deeply buried by other posts
-
Post an announcement titled “New Prototypes and Test Solutions Available”- Looks like the instructor is posting new tests, right? in the body the instructors say “There was an error with the testing prototypes: they displayed the correct values on the screen.” I skipped the content after skimming the title and
-
The PDF requirement asks the students to use the VM to test their code (which intended as the VM environment, not the wrong tests in VM). There were no red bold reminders or corrections in PDF, nothing.
-
The error was founded one month before the deadline, and the error was not corrected.
I met 3 other students in the later group project, who I didn’t personally know before the group formation. And 3 out of 4 of us used the VM test cases as the standard and lost 40-50% points.
This is very sad and frustrating for us as a student
The course was the first course i took in OMSCS. The course videos are pretty dry and boring, but the assignments can be interesting depending on you proficiency with UML. I found the assignment on state diagram interesting. The project relies on ones knowledge in Java, so if that is your strength, then the course will be a breeze.
I don’t think this course is run very well, and most of my issues come from the TAs/instructor and the group project.
If you have experience reading/writing Java, you’re fine. 3-4 of the assignments are text based (reading and writing). 2 of the projects are designing UML documents. 2 of the projects (the individual project halfway through and the group project at the end) are coding projects (Java). As I mentioned, any experience in Java (especially with writing multi-class OO apps) will be fine.
The TAs and instructor didn’t answer questions often, instead referring to minute marks in the office hours. I understand why you’d encourage students to watch office hours, but a lot of us just want to see the answer we’re looking for instead of sitting through 1-2 hours a week of office hours, or scrubbing a video. It just seemed somewhat passive aggressive. The readings are useless. They assign them and hold “reading hours”, but they aren’t necessary at all. The only benefits from the lectures are to take the quizzes for the participation points. Aside from that, you can Google/learn as you go the UML concepts you need.
The group project is a typical group project. I didn’t particularly care for it, as my group wasn’t great (had a major imbalance in ability and workload). The individual project isn’t too tough, I am moderately experienced with Java and it took me about 7-8 hours total over a week or so. The text-based projects (including an essay) are boring and didn’t seem to actually grow knowledge in the subject.
Overall, I don’t think this course is the standard of what I’d expect in OMSCS. Most of the assignments feel like busy work. I also personally don’t care for software dev concepts (such as UML design), but that’s on me. I’d say SDP is a much superior course. If you’re looking for an elective or a course in the computing systems track, try one of the others before this one. However, this course was fairly trivial over the course of the semester, so if you just need a “filler” class, then this is fine.
This class will force you to review some software programming concepts that are quite dry but probably good for you at the end of the day.
A few takeaways after having completed this class:
- No, you probably don’t need formal UML diagrams for work. But is it a good idea to draw a few out at least once, taking this one time to think carefully about how your software system is structured? Probably yes.
- Have you been writing lots of small code snippets for online courses, but don’t know exactly how you’d be able to work with other software engineers to build a larger software system? This course is for you.
- At what other point in your life would you be forced to write about the merits (or demerits) of different programming paradigms?
Disclaimer: I haven’t taken SDP so I’m not sure how the content of this class differs in scope and usefulness.
This class built upon SDP fairly well. The projects are done in Java. We did use Gurobi api in both projects. There was no exam in the summer semester. I felt like the class moved at a good clip for the summer. Seemed like something was do every week or every other week. There is lots of documentation with the UML stuff. There is a team project. We got to pick our own teams. To be honest, I felt like I learned a significant amount from my team member than anything else in this class. The team project is a decent size project so make sure you’re on the ball about picking good team members. I watched to see who was more active on Piazza and who provided good feedback or had decent backgrounds in the field and then asked to team with them. Worked out great. The professor held weekly office hours and answered questions on Piazza. TA’s were active as well. I guess some of the information is a little outdated like the UML stuff but honestly its just another form of documentation and it didn’t seem to egregious to me.
pros:
- professor was very active: weekly office hours, biweekly reading discussions, answering questions on piazza
- interesting readings (IMO)
- project was interesting and realistic
- good course to take over the summer (pretty manageable workload, no exams)
cons:
- videos weren’t really necessary for the projects (they were made by another professor who has since retired)
- TAs were pretty unorganized (not the worst I’ve seen, but not the best either)
A nice course to take as a first class. You will implement something in Java as a group project and there are some individual assignments. Nothing too harrowing. Compared to other courses I’ve taken, this one was clear in its requirements and reasonable about the workload. Maybe not very interesting at times, but someone actually asked me recently in an interview about design patterns, so I guess this material is still alive and well.
Lots of concents which i thought i know earlier, but surprised me when taking this course. Group project was fun one and great.
Too hard to get responses back from TAs to conclude fast.
Udacity video you will see more presenter’s face all time than the text we needed, may be old format. New classes i see more text contents rather speakers face.
This was my second course in the OMSCS program. I had taken IOS(CS6300) in Spring2018 prior this class. Coming from such a great class IOS was, this class was terrible. It is easy to get an A but I did not get very much learning out of it, which is why I am doing this program in the first place. On weeks when assignment was due, you can cram it out and on other weeks that don’t have anything due, there would be almost no work except watch some videos. There was a lot of cramming in the end for the final project. Here is the break down:
Pros:
- Easy to get an A
- No exams so don’t need to stress over material of the lectures
- Can kind of BS your way through since design is very subjective and there is never a “right” answer
Cons:
- TA’s are not very helpful AT ALL, rarely answers piazza posts clearly or even at all. There is no slack channel for concept discussion and questions.
- Assignments take a LONG time trade. Since it takes forever for you to get your assignment back, and even when you do get it back, you don’t get any feedback so you don’t know if what you did was actually correct or not, even though you got a decent grade. Because of that, I went through the entire course not knowing what things I did right or wrong. Up to this point I still do not know what I did for my assignments were correct or not, it was all “my best guess, and what made sense for me”, but it would be very helpful to see other ways of doing the assignments, what to do and what not to do.
- Final project was just kind of thrown at you and he tells you to just go do it. There is no progression or guide in how to do the project so it is overwhelming at first, especially if you don’t have very experienced team members. Also absolutely no feedback for our final project. We spent 85% of our time doing the database which was worth 15 points and we ended up getting 0/15 for some unknown reason. We message the TA and professor and we get no response. It is just so unprofessional.
- Lecture materials apparently are very important concepts but videos do not go over many examples or go in depth to explain anything, how to implement concepts, how the concept compares to another solution. The professor presents the material and thats it. If someone like me has never heard or ever seen what the professor is talking about, I do no learning.
Tips:
- Try to meet up with local students and discuss over topics in lectures and homework requirements (of course following the collaboration policy). This is because design is very subjective. There is never a “right” way to design something. That is what makes the course content difficult to learn.
If you’ve worked professionally as a software developer for a few years, this course is likely going to be a great deal of busywork and a complete waste of time. Dr. Moss inherited this course from a retiring professor. Dr. Moss is great and extremely responsive, but he didn’t create the video series or the curriculum. This course goes into excruciating detail on topics that are unimportant and not widely used in industry. The curriculum needs to be re-balanced and these courses re-filmed. This is the first OMSCS course where I didn’t finish all of the videos. In fact, you don’t even need to watch the videos to successfully complete all of the assignments.
There are some great courses in OMSCS. Until this one is reworked, it isn’t one of them. I highly recommend that you take something else.
Everyone likes to bad-mouth this class for the time spent on UML, and I don’t disagree that this is a useless skill. That said, having some way to organize your design graphically turns out to be very useful, and it’s all the more so if it’s a system that’s consistent enough to be easily gradable. But the real reason to take this class is the dive into design patterns. You won’t have to, necessarily. I think you only have to compare and contrast 4 for the final paper, but having an environment where you have time set aside to really explore different ways of solving problems (and people standing by to answer your questions) turns out to be pretty valuable in the long run.
Very good course - If you want to know about UML, Design Patterns, State machines, this is the course to take.
Took this as the 5th course in summer 2018 semester. I found a disjoint between the course work and the lesson videos. Infact didn’t need to use the videos for any of the projects. A smile read up online on the uml design information was enough to do well in the course.
Personally, there wasn’t much value add from this course.
Overall, easy course. Enjoyed the projects and learned a good amount about UML. Some of the work was tedious but not overly difficult. Final group project was pretty fun although it’s always hard to find a good group that works together. Ideally come into the course with a group already in mind.
Not a hard class. Instructor is really involved having discussions about reading once every 2 weeks and office hours on bluejeans once a week.
Some of the requirements were a bit nebulous, and as a group we left a ton till the end, but this class is doable if you learn to love Java and great UML diagrams.
I really like the course, the course focus on the “system design” and encourage students to discuss a lot of high level ideas. Then after discussing with other students and teammates, you can try to implement the design from scratch (full stack project), it is interesting and a good way to review all the knowledges and skills.
This class was super boring to me, but it was easy to grasp the concepts.
The lectures were really boring; one guy reads off a teleprompter; I watched most of them at 2-3x speedup; I would have preferred a book. I would have rated the course “disliked”, but my work does not require all the ML courses I’ve been enjoying so much, but does require architecture and therefore the class was actually useful to me even though the class itself was not enjoyable.
This class was ok. I took this as my first course in the program because I didn’t want to start out with something extremely difficult, but this was almost the opposite problem for me. I took what turns out to be an almost identical class in my undergrad, so this class was really boring for me and I had a tough time giving it my attention. The work load is pretty light, I wish I would have taken another class at the same time, but again, I didn’t want to do too much in my first semester. The information is not bad and the group project was not hard.
One of the easiest courses in OMSCS. Projects are easy but time consuming. The last project which is worth 20% of the grade was a code based implementation group project which needs to be tightly managed as team members are all over the world and have different experiences.
This is a good course to take as the first one in the program. It is easy to understand and the assignments and projects are well balanced. Mr Moss is an excellent lecturer and the classes are good. There is one group project, but it is not a big deal if the group is responsible.
I took CS-6310 in Spring, 2018 with Dr. Mark Moss. This was my first OMSCS course. I felt like the course was a good first course. It was not too difficult, but it did require me to put in about 10 hours per week on average. Dr. Moss and the a couple TAs were very involved in the course and I feel like they communicated very well compared to what I’ve heard about in other courses. The course was organized and well-run.
There were no tests, just assignments, which included a group project in the final 3-4 weeks. The main assignments were 2 design documents using UML, an approx. 6-7 page (double-spaced) research paper, and and the final group project. There were of course the Udacity videos and some required readings, but the readings did not count as part of a grade. The content was fairly interesting, but I felt like a little too much emphasis was put on UML and not enough on architectural styles. You can’t really work ahead on the assignments as they are released at specified times.
This is a good course for someone from a non-CS background or has little experience in architecture and design. The UML coverage overlaps a little with SDP 6300, but expands beyond that. The early assignments were good. The professor held ~weekly “reading discussions” to discuss research papers, which I found very helpful. Most of the reading assignments were very interesting also. The group project felt like just another group project. It had some design aspects, but little to reinforce the architecture component of the course.
Big disconnect between video lessons, reading discussions and assignments. Probably, in part, due to the fact the professor changed from the the time the video content was created. I thought a disproportional emphasis was put into UML versus SW architecture and design topics. Group project towards the end of the semester is interesting, but if you find yourself in a bad team you may be in trouble as the team project accounts for 20% of your entire grade. Also on grading, it took the teaching body a long time to grade assignments, which can be a problem as, since some of the assignments sort of build on each other, if you make mistakes on an early assignment, you may get penalized for the same mistake on a later assignment. However, grading seemed very reasonable and methodical overall. It was my first course on the program, and one I thought to be a good intro to it after the fact. Probably worth taking it, but don’t expect much learning if you work as a SW engineer on your day job; however, as others already alluded to, it is a Graduate course and you get what you put in.
Some of the grading seemed arbitrary, but it’s a great overview of the topic. Disconnect between the older lectures and the newer approach in the readings and office hours/discussion. Group project was really good, and a good way to get to know others in the program well.
The subject matter of this course is not difficult at all if you are a java software engineer. That said, the workload of this course can be deceptive. There are some assignments that don’t take much time but there are others that do if you want to get top marks. If your goal is to get the highest grade possible then be prepared to put some time into this course but if all you want to do is pass then this course probably won’t require too much. This is grad school so at the end of the day you get out what you put in.
I liked as a first course, not too many hours per week. I ended up spending more time since I had to review the course content more than once partly due to work. However its easy and with the timelines you could make it. Important is the 200 point project, if your team is good you’re good. Make sure you spend sometime learning the UML concepts, they will be used throughout.
This was my first class, and it was a good introduction to the program. Not too difficult, some projects to help get you into the flow of school again (for those of us who last attended school ages ago). The group project was the hardest part, mainly because of getting everyone on the same page and being able to do the requirements on time (there was a lot of wasted time on our part organizing and scheduling). I highly recommend when you get a new project to start right away as the projects always seemed to take longer then one would expect.
This class is probably a good first class or one to save to take with another class. No tests, and most of the work towards the end. I wrote 5 hours/week here but I am not sure how much it actually was, since I basically just completed every assignment the weekend (day) before it was due. The group project was the only thing that required scheduling, but if you have a good group like I did then it’s not a problem; plus it was an obscenely small % of the total grade. The periodic assignments, class participation, and peer feedback was a large percentage, and they were very manageable.
This class went through the motions hitting all the key beats, but focusing mostly on UML class diagrams and state charts. It then touched on and required us to generate behavior diagrams and a deployment diagram. There were periodic assignments requiring various diagrams to be generated for various designs, and then there was a group project. The group project was based on a scenario described in a prior assignment, so the initial work consisted of reviewing the group members’ class diagrams and code and combining all the best parts (or picking someone’s who got a good grade). All of that was fine.
Then there was a surprisingly large amount of coding. It was my first time having to write Java in 10 years or so, and I was surprised, considering design can 100% be done without writing code. Either way, as you can see from my rating, it was pretty easy overall, but I would just be warned that there is significant coding required. Also the videos were weird; I didn’t think they were bad at the time, but having taken a couple more classes since I can see they weren’t great. Also, they didn’t always have anything to do with what we were actually generating for the assignments and the project, but the state chart ones were OK.
Not bad – just not super interesting. I do designs at work frequently and the details in this course I definitely learned but felt that I would never need to dive this deep 95% of the time. Would skip this course if did it again
This course is similar to SW Dev, both in the sense that you have a group project and as far as content goes. I do remember the lessons being a bit dry, and not fully feeling that I had a grasp on all the design patterns and principles when the course ended.
Very good course with a lot of material to learn. It can easily be thought as two consecutive courses in order to spend adequate time on all topics. I loved the videos and the reading materials. Most emphasis is on UML class diagrams and state charts. The design patterns are covered but it deserves more emphasis as it seems to be a hot topic these days. You need to know Java to do the projects.
Assignments were numerous but doable as long as you stay on top of them. Project success was largely dictated by who you chose in your group and whether or not any of them had significant application-building experience.
The course had really good TAs, they were active on Piazza. One thing that got me was the first java assignment, they were very finicky about your program’s output matching the expected answers. Make sure you match the expected answers 100% (keep running diff commands). Make sure you familiarize yourself with UML diagrams, state charts and OOP design patterns and you’ll get an A. The grades come back kind of slowly, but as long as you break the problem down and model it correctly you won’t have any issues. The video lectures are good, actually pretty funny because of the professor’s interactions with the udacity person. This is for sure a first course to get you in the swing of the program.
Use lucidchart for your diagrams, it’s ezpz.
I really wasn’t a fan of this course. The readings in the class were good, and I was fine with most of the lectures, but the quizzes didn’t help reinforce any of the concepts in my opinion. Also the TAs were slow graders, and took quite awhile sometimes to respond on piazza. A ton of the topics are pretty much stuck in the 80s/90s of SAD, so a lot of it isn’t really relevant to today. The class is pretty easy if you have some programming knowledge, especially since there are no exams.
SAD is a good course and gives an overall basic knowledge of software architecture and design aspects and principles. If you are new to architecture and design it’s a good learning and if you have already worked in the software development and design for few years this will be a refresher course.
In general, it was a good course. It was much better organized and prepared than a few other OMSCS courses, and office hours were regular and informative. I’d think that both professor and TA’s could have participated much more actively in Piazza, as it was usually necessary to wait till office hours to get responses to some of most straightforward questions, even questions about logistics and organization. The unpleasant surprise, however, was that the group project, which was supposed to be most highly weighted in the overall grade, was never actually scored (or perhaps it was scored, but score was not disclosed to the students?). Eventually, I of course did get the overall grade for the course at the required deadline, so I thought the project grade is just a little bit delayed, but up to this moment I still see neither grader comments, nor the score for the main project. Don’t know if I just missed it somehow. Perhaps other folks could chime in if that is indeed the case.
Overall the course wasn’t terrible but in some ways misses the mark. You work through building out an application from the requirements stage -> initial individual implementation -> expansion of requirements -> expanded group implementation. This process is incredibly helpful as it presents things that you do in the real world.
What I didn’t like was the weight put on sticking to OOP principles throughout the process. While the instructors have to pick some sort of way of evaluating code, picking specific programming paradigms/features cause problems as it is outside the stated goals of project architecture/documentation/design/implementation. That said, if you have any sort of OOP background you should be OK in this course (another important piece of info is this course is very much a “do your assignments in Java” course).
I got the feeling that this course is somewhat evolving and some of the lecture material isn’t useful for the full implementation of the projects. Hoping that GaTech addresses this disparity going forward to make sure the assignments and lectures converge a bit better.
this class required a lot of work. it also required having a good team. We ended up with a good team initially and picked up some other good members before the end of the semester. it’s one of the most time consuming classes taken so far in the program. It was both interesting and rewarding. Learned a lot along the way.
The course title describes the course exactly. The Udacity videos are very long but thorough. The most tedious part of the course is the UML diagrams, but once everyone found out we can access LucidChart for free with our @gatech. edu emails, it made the process much easier. At the end of the course, there is a final group project that involves creating a user application for a course registration simulation. If your group is responsive and you’re willing to put in the work, your results and grade will reflect that.
As has been said in other reviews, each project builds upon the next, and there is little to no feedback between turning in one part, and starting the next so you have no idea if you are going down the wrong path or not. The last piece of the project turns into a group project and you have to merge each members ideas/work together or start from scratch. I think this was one of the ONLY group projects I have enjoyed, mostly because everyone knew what they were doing and actually did the work. It was spectacular. Hardest part for me was some of the diagrams you have to build. A few of them didn’t really have good samples so I had to do some comparison from the real world examples I could find and hope it correlated back to what was expected in the class.
Software Architecture and Design is what I do for a living, so this class was a breeze for the most part. Completely forgot to turn in one of the projects (wrong date on my calendar, lost 15% of my grade right of the bat) and still got an A. Before this class I had a rather strong hatred for Java. I can honestly say this was the first time I used Java, that I actually enjoyed.
If you have a background in designing or architecting a system, this course should be a good refresher course. The topic presented is broad and the professor presented it thoroughly. That being said, some of the lectures only provide brief discussion and then it is up to your curiosity. The amount of knowledge you learn, hence, depends on your initiatives.
I found the assignment was quite okay and the grading is fair. Piazza forums was active and the TA were really engaged in answering the questions. This helps a lot in the assignment because the feedback for your submission might not be delivered on time for you to work on the next task (and most of the assignments are basically refinement of previous assignment).
Something that I think might be improved is to include modern architecture like microservices or SOA and more examples on the popular frameworks/tools for the implementation. It might be good since most of the students are working professional in the industry.
This course was well structured and took you through the iterative design and implementation process that you might experience working as a small consultancy. You start on your own then move into group work. The class was all project based which I prefer. Grading could be slow but overall I enjoyed this class.
I am a professional software developer who was looking for some formal architecture teaching and the course fits that bill. I found the course lectures to be rather thorough but dry at times (Hey, it is Software Architecture so you can only make it so exciting). The course took you through design and implementation of a Java application. Therefore, you certainly need to be able to program a working basic application that will become more complex as it shifts to the group stage of the course.
My only disappointment with this class is that if you were unsure of a direction you were working towards in your design, you would not get feedback for several weeks which is after the next assignment or two were due. They are very clear that you won’t get marks off for repeat offenses in the case you didn’t get feedback; however, from a learning perspective, this impacted my ability to learn through the feedback while working on the project throughout the course.
The course is a decent mixture of software design with actual implementation. It has no tests, but focuses on a semester-long project that has various design and implementation phases. You will have to make a few UML diagrams (Class, Sequence, etc), write requirements, and develop the designed project in Java.
If you already have experience with Java, and are familiar with Object-Oriented concepts, this course won’t really be hard at all. If you aren’t very experienced with programming in general, I feel that this is a nice starting point to practice these concepts and learn in a very practical way.
The only downside were the lectures, which I didn’t find too interesting, nor did they help me too much with the project per-se, except for a few ones that talk about UML Class Diagrams and others that talk about converting requirements to classes and methods.
In summary, this is a good starting point if you aren’t too experienced with programming. If you are, but want to start off the OMSCS with a not-too-difficult class just to get an idea of how the whole program runs, this is a good option as well. However, I wouldn’t suggest it to an experienced software engineer. For those students, there are other courses in the OMSCS that would teach them more useful things.
When I took this course it was a tremendous amount of work. It was not an easy course and the way that it is taught varies from Professor to Professor. That being said, I would not take this course with any other course. I would recommend that it be taken by itself. The subjects that are covered are important and work to enhance your domain knowledge.
1) This course is extremely difficult on very many levels. Though the course name is SAD (D stands for Design) this is course involved too much Code Development. So unless you are GREAT in Java programming (I mean, you need to be a Guru in Java, being good enough just won’t cut it) please do yourself a favor and skip this course. Mind you, they don’t teach you Java on this course at all.
2) All projects are cumulative which is not a bad thing but they take their sweet time to grade and return the previous projects, so if you make mistakes in the previous ones you carry them on to your next projects. So it is a double whammy!
3) One TA admitted to me that they were instructed to be extremely stringent in grading. Tons of marks were deducted for very flimsy reasons. Regrade requests are entertained but usually doesn’t change anything. No motivation to study, correct the mistakes and improve at all.
4) Tries to cover a lot of topics without giving sufficient, valid examples (eg. OCL). And then you get dinged for that (for something you were never taught to begin with!).
5) Absentee professor. Professor doesn’t teach this course. He doesn’t appear in any of the course videos or lectures and rarely visits Piazza. Office hours are conducted by TAs and sometimes the professor pops in there. In the 8 OMSCS courses I have taken so far, I have never seen this. The Professors always taught their respective classes.
6) Do NOT expect any grade curving. Even if you score 79. 99%, you will get only a “C”. For some other courses you can easily get a “B” or even “A” for 79%.
7) As another student pointed out, this course is way out of touch with the real world. I have been a designer/developer for 20+ years now. Never ever worked on any UML translations.
The Course is OK. However, the response from TA and instructor is relative slow. Sometimes, we would not get feedback from them 3 weeks after submission. In my opinion, the course material needs an updated for more design pattern coverage.
I was hoping to get a glimpse into modern software architecture and design techniques, but instead, I got UML. In my own experience as a software engineer, it has been sufficient to simply be on the same page as business partners and make sure you understand their requirements. Regular code reviews with senior team members and architects would help to ensure proper code design and quality. I have never once had the need to “translate” requirements into any kind of UML diagram. The assignments had a lot of “busy work” around this UML and in one case there was even an essay portion to discuss the pros and cons of various architectural styles. I actually found that useful despite it being a bit tedious.
Having coded in Java for many years between school and work, I found the coding assignments to be a breeze. Having the last two assignments be group projects really didn’t help matters. I went all out on the last assignment to make sure the team would get high marks, even though I didn’t need them. The last assignment was valued at only 100 points (10% of grade) but I feel like it should have been a lot more given the amount of effort that was required to complete it.
The lectures weren’t particularly engaging and there was a requirement to complete all the quizzes in them to get full participation marks. After the first few lectures that introduce the student to UML and OCL, I didn’t feel like I needed the knowledge provided in them to complete the assignments. Indeed, I watched the first two and a half parts, then never watched them again until I had completed all the assignments (only to get the participation points). In the end, it was a very average course for me. Not particularly bad, but not great either.
Enjoyed the course. Loved how the assignments built off the prior assignments.
Not sure if videos should be refreshed however towards the end the videos were not very helpful.
Instructor and TAs were very responsive.
The material was pretty straightforward, especially if you’ve had any experience working for a large organization. Some of the stuff was a little tedious to implement. Additionally, the workload increased dramatically toward the end of the semester with implementation stages and team projects.
The concepts were not that hard to learn, but were time consuming to implement, especially as a team.
There were 6 assignments (4 individual and 2 group). Your overall grade is based on these assignments and class participation (completing all quizzes and actively on piazza). I took a Software Design course during my undergrad and as expected this went more in depth than my undergrad but not as much as one would think. The videos were well put together but after the initial assignments did not have relevance to the course. I liked the idea of the assignments taking you through a realistic software design and implementation case. Each assignment built off of the previous one as far as requirement modifications by the client with the final assignment ending with the product that you slowly designed throughout the semester.
I rated this class low because I think the class was harder than it needed to be. There were 3 issues I had throughout the semester:
-
Feedback (aka grades) was delayed throughout the semester. The assignments were ordered as design1 –> implementation1 –> design2 –> implementation2 –> finaldesign3 –> finalimplementation3. The issue is we turned in design2 and implementation2 without feed back from the 1st assignments. This was an ongoing issue. HOWEVER, i will be FAIR and say that instructors were very active on Piazza.
-
Grading was vague and seemed to vary alot between TAs. The instructors manually graded the 1st assignments but then used an autograder for assignment2 implementation. However, they did not provide us the test suite they used for the grading until afterwards. This seemed unfair and led to much controversy in the class.
-
I found that most of my time was spent coding rather than focusing on the best design. In fact, UML design patterns were not emphasized at all in this course and due to the feedback we were not sure whether our design was okay until late in the semester. I do appreciate the instructor giving us the opportunity to code a little more but it was almost too much for a course that should be about design.
This class was okay. Not sure I learned a whole lot. Seemed like a repeat of 6300 honestly. The lectures are long and pretty boring. The assignments are mostly UML diagrams with the exception of the one coding project you do throughout the semester. Grading is suppppper slow and pretty careless. I constantly had to ask for it to be reviewed. No tests. All Java, cmd line stuff.
50% Projects 20% Assignments 20% Exam 10% Class Participation
The projects were and assignments were doable if you had a good team, but this course is entirely team dependent. The good thing is that unlike some other courses, you can choose your team members. The exam is straightforward as long as you watched the lectures, or did the assignments. The second project was pretty nice, since it allowed you to develop a whole system, and allowed the students to work with many different components and languages, which I found useful. The biggest annoyance with the projects is that they require you to interact with a Gurobi which is very poorly documented and hard to use. I spent more time in this course learning that Gurobi than I did doing anything else. That being said, you can pass this course or get an A, as long as you put in the time and the work.
Biggest complaint about the class was that it seemed the majority of the first project had to do with mastering Gurobi, which IMO, had nothing to do with Software Architecture and Design. This was a make it or break it. Thankfully, after many hours, I was able to figure it out.
Biggest upside to the class is once you figured Gurobi out, the rest of the project which included, of course Software Architecture and Design and then implementing that design, was pretty fun. A good project and the implementation could be in any language.
Lots of good techniques and knowledge taught here, although, in my 30 years of software development, haven’t had to use UML, and probably won’t for the remainder of my career, but still good to know.
Decent course. Course involved one group project when I took it, which took a ton of work due to other students not pulling their weight. Otherwise, class was interesting and I learned a decent amount.
Enjoy this course a lot. I was happy that I was able to learn the different architectures and actually put them in play
I had taken UML classes before, so this was more like a refresh on the concepts. The only problem at least with this summer term was that the feedback took too long for each assignment.
Good course. Definitely applicable to most work places. Good experience with the team project. The assignments that require drawing (diagrams and so) took me a very long time to complete. Not a hard course, but very time consuming.
This course - at its core - teaches two things:
1) the syntax and conventions of UML diagrams: class, sequence, state chart make up the major players. Other diagrams get supporting roles.
2) the taxonomy of architectural patterns that arose as software systems and their teams became larger over the history of the industry
It delivers on those two fairly well. However the standout feature of the course, to me, was ILP (integer linear programming) with the commercial-grade solver Gurobi. I knew nothing about ILP and now I can’t get enough. I have an extensive Java background, so learning “ILP in Java” meant one new thing paired with one old thing. NC State University hosts a large library of Gurobi code samples in multiple languages. Find them!
Every silver cloud must have a dark lining, so caveats from my view:
1) grades focus on the syntax of your diagrams, not the quality of the architecture expressed. I got all points on syntax-perfect diagrams of ideas I considered underwhelming.
2) in summer, grading took forever. I didn’t get any informative grades until two days before the drop-with-W date. You cover half the courses’ content before you get grades on the first real assignments.
3) also in summer, course staff did not assign any OCL homework, despite several hours of lectures and a reading on OCL in the syllabus. a one hour overview would suffice, without using OCL for any assignments where we can practice and receive feedback.
4) another summer specific comment: some assignment windows overlapped, including the final project.
I was part of the Spring 2016 class as well, overall I really enjoyed the class and learned a lot. This class was overall not difficult in terms of the content that was taught. However, the programming projects were a bit more difficult and extremely time consuming, thus the reason for my higher average workload feedback. Mark Moss was a very good professor. He attended all office hours together with the TA’s. TA’s were also very responsive on Piazza as well, so support was easy to get if you asked for it. Projects were all java based which was nice because my Java background is lacking, so I was able to learn a new programming language as a result. In terms of project details, the first project was not team based and required decent knowledge of optimization concepts and the use of the Gurobi optimization framework. So you would be wise to brush up on Linear Programming optimization. Projects 2 & 3 were team based and as someone else mentioned on a different review, if you have a strong team, you will love this course! We had a diverse set of skills that allowed us to get very good grades on the projects, in addition to coming up with really cool designs and implementations. For our last project, we pretty much designed a full web based distributed application that utilized Vaadin (web gui), Spring (MVC framework), and the Gurobi optimizer. These are all technologies that I believe are used in the real world so I believe I can really apply what I have learned.
This class was fun and I enjoyed it. However, my experience was probably due to the amazing team I had to work with. Almost everything is team based. The projects are big and hard, but no too hard if you have a good team. There are several weeks where you need to be working on your big project, but they assign you a research paper to do at the same time. They aren’t big, but almost seemed irrelevant, like a side nuisance in the grand scheme of the projects. Plan to spend lots of time on big projects and get yourself a good team right from the start. It will make this class much much easier.
Though it was stressful at time, overall I liked this course. Professor and TA’s were very responsive on the Piazza forms, though they were at time slow on returning assignment and project grades as well as updating mistakes in the grading.
Overall the workload depended on the week. When there were no projects released or assignments due, I would typically spend only a few hours a week. When a project was due, I would spend closer to 20 hours a week. I would recommend starting on projects when they are released, as if you do not, you will end up having to pull some late nights. The lectures were informative, but really did not cover what you needed to do on projects and assignments in great detail, though I think the professor’s point that you cannot teach design through lectures is valid.
The one thing I really did not like about the course was the choice of technologies we had to work with. The projects involved implementing a tool called Gurobi, which is very poorly documented, and very hard to work with unless you understand what you are doing. For the first project especially, I spent at least 75% of my time trying to get Gurobi to work and 25% actually focusing on what the course teaches.
I learnt UML and OOAD back in 1999 when the three Amigos were the three Amigos - Booch, Jacobson and Rumbaugh https://en. wikipedia. org/wiki/Unified_Modeling_Language I had to switch careers during the 2001 meltdown. Its good to be back learning OOAD again. This course has a very interesting perspective on teaching UML and OOAD. You have to know or learn ILP and java since the solver is java based There are no fixed answers to the projects since in real life there are no fixed design solutions. The same with the requirements. In real life requirements tend to be vague and it takes a good analyst to fill in the blanks. Take this course with an open mind and you will learn a lot.
This course felt like a continuation of Software Development Process. It is not meant to be, but the topics built upon what I had already learned, so I’d recommend you to take CS6300 before taking this one.
Again, be ready to write lots of documentation and spend a long time diagramming UML. There’s also quite a bit of Java involved, so make sure you’ve got a good understanding of the language before adventuring in this class.
There are several assignments where you’ll be modeling solutions to different problems and writing a lot of content. I specifically remember the Stateflow diagram problem stealing more than a few hours of sleep from my nights.
To me, the best part of the course was learning optimization with Gurobi and applying it to a real problem. There were three projects, all related to an application that needed to optimize the scheduling of classes. It was an exciting and challenging exercise. The final deliverable takes time, so start as soon as possible.
The final exam wasn’t particularly complicated and it was open notes. You can pass it using the video lectures alone. I studied like crazy and then found it to be easier than expected.
On this class, you work on teams. I began to be very picky during the selection process, and I ended up with a great team. We had our challenges but ended up pulling through and completing all the work on time.
It was an ok course. I have a lot of professional development experience so I didn’t learn anything eye opening. I was hoping I would enjoy it more than my undergrad design course (after 14 years on the job). It didn’t really turn out that way. As with a lot of courses, the workload varies depending on the assignments due. One thing I didn’t care for is the team-based projects. I had a great team and enjoyed working with them but some times it felt like I couldn’t really do things on my schedule, so I would have preferred working alone.
The high point for me was the first project which had an interesting problem not related to software architecture. I had a lot of (stressful) fun trying to figure it out. So I will probably start focusing more on those types of classes.
For me, the main takeaway from this course is a better appreciation and interest in software design. Beyond that, if you’ve taken a Software Architecture course before in your undergrad, most of the material will be very familiar.
This course is very strange, and I was very disappointed from its offering and content.
downside: Other then that, this is a total waste of time. The lectures are super boring and outdated (too much in high level) and not relevant for 2016 - you we feel like you are 15 years back in time - This is a shame. The assignment are very general and will not provide you any added value. The course is not being organize and it feel like lectures, projects and assignments that have nothing to do to each other, and 80% of the content will need help you in your career.
upside: You can learn a lot from the projects, but I do not think that they were managed and specified poorly.
Be prepare for lot’s of hours being spent on the projects.
If you want the same basic content in a much-better-prepared course, take 6300. They two classes use several of the same lectures; and both cover analysis, design, and architecture. The lectures are not very helpful as they keep referencing optional material in the course wiki that winds up being required to complete homework, and the prereqs are sadly understated (you need a good grasp of UML/OCL going in, be ready to build linear programming solutions). Be ready to buy/read all optional material listed in the course syllabus to just keep up. If the course description had been more accurate up front, I would definitely never have signed up for this class.
This course ended up being much more time consuming than I had originally expected. A normal week I probably spent about 10 hours, but weeks in which projects were due it was more around 20-25 hours. The material itself is not very difficult, and I enjoyed the subject topics covered. The lectures were very informative and to the point, though at times a bit dated. The professor states how it is hard to teach design, as design is best learned by doing. Yet most of the assignments were short 7 page research papers on various subjects, when smaller programming assignments or design problems would have been a better choice. I did learn a lot about the subject and thought it was well presented. That being said, I do have two major gripes about this course:
-
Feedback and Grades. I understand that these large online classes tend to have a less than ideal student to grader ratio. But it took a VERY long time to get feedback on turned in assignments. Sometimes grades would come back without feedback, leaving me wondering why I got points off. There were several assignments that were not returned before the final exam or before the last project were due, which would have been extremely useful for the completion of those two. Throughout the semester it was hard, if not impossible, to tell how well you were doing because we didn’t have any graded assignments returned, even though some were due 1+ months prior! The TAs also seemed to avoid questions on Piazza asking about when we would receive grades back, or just give an answer saying they did not know.
-
Group projects. BEWARE OF GROUP PROJECTS. The assignments for this class were mostly all done in groups. At the start of the semester the group forming process was not made clear whatsoever. We were asked to make 1 min long intro videos about ourselves and our experience, which I assumed would be used to help form groups. But we never saw them. When the first group assignment came out, we had to use Piazza to try to hastily form a group. And as it turned out, that was the group we had to use for the entire semester. If I had known that, I would have taken more care into the selection of my group members. Most of the assignments ended up being research papers, but the last major project required significant software development. KEEP THIS IN MIND WHEN SELECTING YOUR GROUP!! Other members of my group were not well versed in software development, while I am. This left me to do a huge portion of the project just due to time constraints and my previous experience. I honestly would have been better off doing it all myself. Keep this in mind if you take this course!
Overall I give this course a 4/5. I enjoyed the material and learned a lot about software architecture and design. While time consuming, I enjoyed the class. Just learn from my naivety and be careful when selecting a group
- 50% Projects
- 20% Assignments
- 20% Exam
- 10% Class Participation
The four projects build on one another to ultimately produce an app that uses a linear programming engine (Gurobi) to make course-enrollment recommendations given student/admin input.
The assignments require writing a document covering a particular topic. I thought pursuing CS would be an end to writing essays, but I was wrong.
The final is open-book, take-home. As long as you’ve watched and internalized the lectures, it’s straightforward.
Has to be the worst class I’ve taken in my college career. The workload is enormous, topics are not relevant to the real world, instructional materials such as the videos are beyond terrible. The only good thing I can say about this class is that it ends.
This class has a high workload: multiple 7 page papers that are each worth around 4% of your grade, projects that have a program and two 7-10 page papers worth 15% (total). They are group assignments but because of the high number of students dropping out and people without a programming background you are lucky if you have 3 people working on the project. Compared to other high-workload classes, SAD isn’t rewarding because I don’t think that the material is all that interesting or useful (at least to me).
Super dissapointed in this class. I feel like there is a huge rift between the amount of work I have done and the amount I have learned. Understanding lecture material does not coincide with Project success… hopefully if you take this class their will be enough team members with advanced Java skills. Dealing with many different groups with different members in different time zones also subtracts from the quality of the course. Strange and contradictory assignment requirements and nitpicking grading… the list goes on. I feel the quality of CS6300 was many times higher than this course.
The only reason the class is somewhat difficult is because it’s SO boring. The material is completely irrelevant, and mostly has nothing to do with the real world. Very disappointed in this class, and is by far the worst I’ve taken in the program.
The topics are interesting, the projects and overlapping assignments done as a team are a nightmare for coordinating during non-work hours. Many people dropped the course because of this, which made it even harder for their team members.
The less enterprise you are, the less happy you will be with the materials. Team-based projects and assignments could go either way. It could be painful, very much so even, if the team doesn’t have a good dynamic. On the other hand, it feels really good with strong teammates.
You should know or have time to learn how to troubleshoot threading and animation in Java. Items (e. g. , sequence diagrams, state charts) taught in theory only, learning how to apply the concepts to Java code is DIY. Enough material wasn’t ready this semester (project solutions for the prof, a. uml model for the ocl assignment, a 3 credit workload) that refunds should have been allowed throughout. Time-pressured teammates drop, conclude there’s no time to communicate adequately. Positives: LogicBlox and Geeks in Black lessons
Very poor ROI in this class. A lot of effort for very little value. If you have been in inudstry for a few years and already know the basics of architecture and design, don’t take this class. Majortiy of the content isn’t relevant, is just common sense, or something you can learn in a few minutes on the net. All topics are covered briefly. More time should be decidicated to the most relelvant topics. All the team-based assignments and projects can be frustrating especially when team members drop in the middle of a project. This creates hell for the other team members. And unfortunately, team members dropping the class is common due to all the items above.
The assignments are not difficult, especially with teams. Most, if not all, of the assignments could be accomplished by a single person, so dividing amongst 4 or 5 people makes them easy (For one assignment, the TA’s recommendation for splitting work was for everyone to do it themselves and compare answers). However, constantly changing teams for every assignment and project is a nightmare; plus, they overlap. In eight days I had been on 3 separate teams. The projects aren’t too hard either, but time consuming and the content is boring. I was expecting a follow up to 6300 which I enjoyed. Instead, I, like many others, just dropped this course. For what it’s worth, my grades on all assignments were at or above the median, so this isn’t sour grapes. Just a terrible class. Note: There’s also a ‘class participation’ component, based on Piazza. As students pointed out, this leads to a lot of noise on the forums and makes them even harder to glean important information from than it already would be.
I’m currently in the class and doing well, but am disappointed with the class in general. I feel like I’ve learned very little yet expended quite a bit of work and effort. Working with many random teams across different time zones can be problematic. Often people drop class or simply don’t contribute their fair share to the team. The material itself seems boring and dated to me. I suspect there are some jobs that would make use of the different items that are covered, but I’ve only seen a handful of them used in my working experience.
Agree with the anonymous poster 2 spots above me. Everything is in group projects so at any given time there are at least 2 groups you need to be keeping track with. Which is extremely annoying. The content isn’t difficult, the structure of the course is what makes this course difficult. If I didn’t have to rely on other team members, I feel like I would be doing much better in the class. This is my first semester, but this is also the worst class I have ever taken. I have an undergrad in CS. I can’t tell you how much I despise this class. The content is extremely boring and outdated. I was hoping to learn more code architecture in this class, but instead I’m learning how to create diagrams that I’ve never had to use as a software developer for the last 8 years. Very dissappointed.
Random – in a nutshell. Awkward course design. Too much emphasis on group projects with random team members; subjective participation criteria (15% of the grade); unclear expectations.
Terrible class. Lectures are long, uninteresting and basically consist of a bunch of common sense that doesn’t make sense. Assignments (which contribute only ~2% each to the course grade) are usually a 7 page paper and are group based and due a week after being assigned. There are 3 projects (each contributes 15% to the course grade) and you are assigned to a different group for each. Each project has 2 10 page papers plus the Java code for the project. There is no limit to the minutiae of detail on what is expected on each assignment and project. This might be considered a good thing, but it really isn’t when the detail on the project changes during the course of the project and the format required on the papers isn’t consistent with what the grading criteria are. Grades on the assignments and projects are not returned in a timely manner (they can’t be given how involved the projects and assignments have to be). And even after the assignment or project is complete we have no idea of what would have received a 100% (no exemplars or even a diagram that works) - so how can we learn what to do better? Numerous classmates dropped the course which makes project completion even more difficult.
Summary: Very time consuming and difficult - BY DESIGN.
I agree with most of the other comments, but would add that the three projects are poorly considered, poorly specified and consume a lot of time unrelated to software design. The instructor attempts at clarification added to the confusion as often as not. My summary: the course is a huge amount of work inefficiently applied to sofware design topics that would have been state of the art in 1994.
Assignments are all group-based and require an obnoxious amount of time. Material is useful if you have never worked professionally or have a weak background in software engineering methodology. Expect the the time requirements of this class to impact your other concurrent classes.
Topics covered are not hard concepts but workload is crazy. This class covers a ton of material while assigning a lot of work. Often having multiple assignment at the same time. This class does not fit well with taking another class at the same time.
I liked the lectures and readings, but wish we’d had a chance to explore some of the key subjects (such as design patterns) in more depth. Some of the best lectures were the ones that were more interview/interactive in nature. The team focused nature of every project AND every assignment means you’ll spend a lot of time coordinating with other people. The projects (45% of the grade) were physics-focused and we had to spend a lot of time dealing with those aspects of the project, which distracted from time to focus on the software architecture. The final exam covers the entire course, so do yourself a favor and prepare study questions as you go so you don’t have to re-review and cram the week before finals! Overall, you’ll definitely learn a lot in the class, but some of this stuff has to soak in over time and experience. I think with some tweaks this course could be really great; there were definitely some frustrations (and that’s perhaps the price we pay for being the first group to take it online) but I think they are serious about trying to solve those for the next offering.
If you like skeet shooting, take this class because the project instructions are a moving target. This is not a physics course, however much of the development time on the projects will be devoted to figuring out how to model heat diffusion. The instructor should provide code or a jar file that can be used to perform these arbitrary calcualtions so that the students can focus on the real goals of the projects which should be learning how to architect and design a system. The instructor expects perfect papers, yet his course material is riddled with errors. There is even a dedicated place on the class forums to report these ‘bugs. ‘ The only positive aspect of this is that it counts for class participation. I found many of the problems I reported just by copying the instructions and doing a spell check in Word. I know of 2 students who dropped other courses and one who withdrew from school because of this class. If you take it, be ready for a roller coaster ride. I never realized how much stress and anxiety can produce physical symptoms until I went to the doctor and she said I was likely experiencing a rapid heart beat and night sweats because of this class. The best thing about the whole experience is that now I have a profound respect for those people who deal with panic attacks on a daily basis. Worst class I’ve ever taken. Constantly made me consider dropping out of school. I almost think he made it this hard on purpose so it can be a ‘weeder’ class. I can just imagine him leaning back in his office chair and grinning as the negative feedback surveys come rolling in. Despite all of this, if you have to take it, try not to stress too much becasue I think (hope) most students will end up with an A or B regardless of the actual grades. See his ‘grading philosophy’ at https://www. udacity. com/wiki/saad/faq. One other positive… It has given me a greater appreciation of my free time because there are weeks on end where you have practically none.
The class content is not difficult but the workload and the high amount of content makes it a difficult course. In my opinion, there is too many assignments and projects. It feels like the professor tries to have enough assignments and projects so we can put the class material into practice. The end result is a class that is heavy in assignments/projects and you end up spending a lot time here. If you plan to take this class either make it the only class for the semester or make sure you other classes are easy.
I have finished the class. If this were my first OMSCS course, I would likely not continue in the program. I hope I can give feedback that will be constructive. First, there should be fewer assignments, they should be shorter, and they should be individual. I say this because I know a limiting factor is the workload on the graders, so some combination of fewer/shorter assignments can result in them grading the same number of pages as they do with the current set-up. Second, the projects need to be set up in a way that recognizes teams do not meet in person, and that teams are comprised of a wider variety of CS backgrounds than one would find on the on-campus program. People without programming experience can’t contribute to the code, nor can they contribute much to documents that require understanding of the code. Third, the administration of the final exam has been a disaster. More than a few lucky students have been allowed up to three hours to take the test by their proctors, while others given only 60 minutes. To do well in the course, you must have some lucky combination of getting assigned to the right project teams, getting assigned to a lax grader, and getting a proctor who gives you far more than the allotted time for the final exam.
My only complaint about the projects is that there was a significant amount of Physics domain knowledge required. Thankfully, on each team I was on there was always a physics guy, which was invaluable. The assignments can easily be done on your own, but I believe the group requirement for the assignments was to make things easier on the markers. Coordinating a group on the assignments was trivial; however coordinating the group for the projects was decidedly more difficult. I had two great teams, and one bad team, but I wouldn’t use that as a reason to get rid of the group work. I found the group work a great way to meet other people in the OMSCS program. The course web site states that you need to know how to program, and that there will be group work. A few small tweaks, and this course will be awesome. This course is a lot of work, but I wouldn’t steer clear of it.
The projects in the course need to be restructured a bit. Too much emphasis on figuring out Physics-related requirements takes focus away from the project purpose of learning about Software Arch and Design. About 10% of project work was directly related to what we learnt in course. Rest of completely irrelevant. I thought the assignments were good. They reinforced things learnt in lectures. But they team based and that should not be the case. They are small enough for individual work. Plus the learing would be better if the entire assignment was done by a single person. Currently, sections of assignments are split up and you rarely get a full view of the topic at hand. Projects should be cut down in scope and grading emphasis should shift a bit more towards assignments. Since I had teammates who were in my timezone or in the zones at max 3 hours away, coordination wasnt really an issue. I am glad projects were team based since that is one way to meet other people in the course and learn from them. The course has some great content like design patterns, design pricipiles and architectural styles. However, first section focuses on UML/OCL and pretty much everyone who had sw dev experience said that it is not very practical. We spent a lot of time on that in the course and during projects and it feels like a waste of time. Instead, if the lectures focuesd more on the other three topics I mentioned and go in depth about them, it will be useful. Some of the lectures on these topic were just ‘read-a-list-from-telepromptor’ type and that was really disappinting. With some modifications, this can be a great course.
Expect a lot of group work on poorly designed projects and exams. While the professor is very enthusiastic, his lectures are very dull. The workload is so much because of the tedium, not the challenge. Unless the projects change, expect to spend too much time research math formulas and debugging temperature modeling than actually understanding architecture design.
Ditto most of the above comments (especially #12 and #14… ‘Artificially Difficult’ gave me a chuckle). Most folks who have been in industry for a while are unlikely to be impressed. Many of the lectures are just recitations of long lists of whatever (UML diagrams, architectural patterns, etc. ) without any depth. And a closed-book, 60-minute final exam containing plenty of questions of the form ‘Regurgitate the 4 types of blah covered in the Leroy & Jenkins paper’ was an appropriate ending.
‘This was an interesting course. As mentioned earlier, there are 3 projects which take up a lot of time, only if you are actively involved. The assignements are interesting and you get to apply what you learn in the lectures. You are free to choose your own team for assignements. THe project teams are pre assigned and your team pretty much determines how you end up doing your projects. THe projects are Java heavy and the teams are assignend such that there is one or two Java pros in each time. The proficiency of the Java person will determine the outcome. They are vast enough that everyone in the team will be involved if they so desire. The second project was very physics heavy, but I enjoyed doing the third project. The professor and TA is actively involved in piazza and had many hangout sessions. There are rooms for improvement but, overall, this is a good course. ‘
Same as above comments. The workload is big and time consuming and yes you will learn some things, but the majority of my group(s) time was spent debugging code and not really focusing as much on the documents like we were suppose to do. The projects span about a month or so and require good teamwork or else you end up pulling all nighters on Sunday nights getting it finished and during the project period you will also have 1 - 2 group assignments with different groups usually. The videos were informational yet a little dull, but watchable. Overall it wasn’t diffcult, but again expect to spend a lot of time doing group work in this class
The aeronautics prof was admitttedly ‘monitoring’, rather than attempting to answer questions, and the TAs had only just taken the course themseslves. Again, the assigned projects weren’t done by anyone ahead of time (aside from a late, failed attempt). And again as a result important staff steerage was bum. <p/> I was retaking the course to ask the many questions I ran out of time to pose last semester, but w/o the prof of origin no one could answer any of them (mostly harder questions about the videos that still deserve an answer). Expect to do creative writing, e. g. , describe your algorithms that don’t exist as if they do.
The aeronautics prof was admitttedly ‘monitoring’, rather than attempting to answer questions, and the TAs had only just taken the course themseslves. Again, the assigned projects weren’t done by anyone ahead of time (aside from a late, failed attempt). And again as a result important staff steerage was bum. <p/> I was retaking the course to ask the many questions I ran out of time to pose last semester, but w/o the prof of origin no one could answer any of them (mostly harder questions about the videos that still deserve an answer). Expect to do creative writing, e. g. , describe your algorithms that don’t exist as if they do.
This was an extremely time-intensive course. It feels like someone took a software architecture course from 10 years ago and went too deep trying to evaluate it. It felt like the Professor needed to make his mark on the course by adding additional assignments, in this case some problems in Linear Programming. Doubled the course load, poorly-defined requirements, and very little guidance from Professor. TAs run amok (though I have to give them some credit for trying to deal with an overloaded situation).
The material was interesting, and pretty much an example of why I joined the program. However, the workload was very group intensive, and it gets tiring working with and coordinating with a team for nearly every project. I was lucky and had a great team, that not only did well but kept together for the whole course. But still, I vastly prefer to work on my own and at my own pace. In addition, the first programming assignment was awful. It assumed a level of knowledge of Linear Programming that wasn’t even hinted at in the prerequisites, and caused a huge amount of problems for students that couldn’t interpret the requirements. The required papers were tedious as well. They all followed the same formula, and were harshly graded to strange standards. I really don’t feel I learned anything at all from writing the papers.